黑马程序员——java中的多线程

------- android培训、java培训、期待与您交流！ ----------

多线程

运行main函数的线程称之为主线程。

创建线程的方法
第一种方式：继承Thread类。
步骤：
1、定义类继承Thread。
2、复写Thread类中的run方法。
目的：将自定义代码存储在run方法。让线程运行。
3、调用线程的start方法，
该方法两个作用：启动线程，调用run方法。

示例
class Demo extends Thread
{
public void run()
{
代码
}
}
class ThreadDemo 
{
public static void main(String[] args) 
{


Demo d = new Demo();
d.start();
}
}

第二种方式：实现Runable接口
步骤：
1、定义类实现Runnable接口
2、覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3、通过Thread类建立线程对象。
4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
将Runnable接口的子类对象传递给Thread的构造函数原因：
自定义的run方法所属的对象是Runnable接口的子类对象。
要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
示例
class Ticket implements Runnable
{
public void run()
{
代码
}
}
class  TicketDemo
{
public static void main(String[] args) 
{


Ticket t = new Ticket();
Thread t1 = new Thread(t);//创建了一个线程；
Thread t2 = new Thread(t);//创建了一个线程；
t1.start();
t2.start();


}
}


实现方式和继承方式有什么区别呢？
实现方式好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式。

两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。



解决多线程的运行安全问题：

同步代码块
synchronized(对象)
{
需要被同步的代码
}
对象就是是锁。对象一般使用Object，持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
现实例子：火车上的卫生间（只能进去一人）

同步函数：
用synchronized修饰即可
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
如果同步函数被静态修饰后，使用的锁不在是this。因为静态方法中也不可以定义this。静态的同步方法，使用的锁是该方法所在类的字节码文件对象： 类名.class  该对象的类型是Class

注：sleep是类Thread的静态方法，使用会抛出异常，需要处理或声明抛出

同步的前提：
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源，

同步的表现形式：
1，同步代码块。
2，同步函数。
两者有什么不同：
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。


单例设计模式

饿汉式。

class Single
{
private static final Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}

懒汉式

class Single
{
private static Single s = null;
private Single(){}
public static  Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s = new Single();
}
}
return s;
}
}