黑马程序员---多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、多线程

进程：正在进行的程序，每一个进程执行都有一个执行顺序。

线程（thread）：是指一个任务从头到尾的执行流，进程中至少有一个线程

扩展：jvm启动不止一个线程，负责垃圾回收机制的线程。

多线程可以使程序反应更快、交互性更强、执行效率更高。多线程具有随机性

创建任务和线程：

任务就是对象。为了创建任务，必须首先为任务定义一个类，任务类必须实现Runnable接口。Runnable只包含一个run方法。需要实现run方法来告诉系统线程是如何运行的。

任务必须在线程中执行。Thread类包含了为任务而创建的线程的构造方法以及控制线程方法。

Thread类：Thread（） 创建一个空线程

Thread（task:Runnable）为指定任务创建一个线程

start（）：启动线程使方法run（）被JVM调用

isAlive（）：测试线程当前是否正在运行

setPriority（p:int）:设置线程优先级p（范围从1到10）

join（）：等待线程结束

sleep（millis:long）：线程睡眠指定的数

yield():使线程暂停并允许执行其他线程

interrupt（）：中断线程

注意：因为Thread类实现了Runnable，所以，可以定义一个Thread的扩展类，并且实现run（）方法，然后创建这个类的一个对象，并且调用它的start方法来启动线程

为什么要覆盖run（）方法

Thread类用于描述线程。该类定义一个功能，用于存储线程要运行的代码，该存储功能就是run（）方法，

也就是说Thread类中的run（）方法，用于存储线程要运行的代码。

线程小例子：

public class ThreadDemo {/** * 编写两个线程，和主函数交替运行 * @param args */public static void main(String[] args) {// TODO Auto-generated method stubTest test1=new Test("one");Test test2=new Test("two");test1.start();test2.start();for(int i=0;i<10;i++)System.out.println("main run....."+i);}}public class Test extends Thread{private String name;Test(String name){this.name=name;}public void run(){for(int x=0;x<10;x++)System.out.println(name+"run...."+x);}

运行结果：

1、两种创建方式的区别

        继承Thread：线程代码存放在Thread子类run方法中。

        实现Runnable：线程代码存放在接口子类run方法中。      

2、几种状态

        被创建：等待启动，调用start启动。

         运行状态：具有执行资格和执行权。

         临时状态（阻塞）：有执行资格，但是没有执行权。

         冻结状态：遇到sleep（time）方法和wait（）方法时，失去执行资格和执行权，sleep方法时间到或者调用notify（）方法时，获得执行资格，变为临时状态。

         消忙状态：stop（）方法，或者run方法结束。

注：当已经从创建状态到了运行状态，再次调用start（）方法时，就失去意义了，java运行时会提示线程状态异常。

见图：

实现Runnable接口，创建线程

创建步骤:

 a，定义类实现Runnable的接口。

 b，覆盖Runnable接口中的run方法。

 c，通过Thread类创建线程对象。

 d，将Runnable接口的子类对象作为实参传递给Thread类的构造方法。

e，调用Thread类中的构造方法开启线程，并调用run方法

实现方法和继承方式有什么区别呢？

实现方式好处，避免了单继承的局限性。

在定义线程时，建立使用实现方式。

代码举例：

public class Ticker implements Runnable{private int tickernumber=100;@Overridepublic void run() {// TODO Auto-generated method stubwhile(true){if(tickernumber>0){System.out.println(Thread.currentThread().getName()+"卖票"+tickernumber--);}}}}public class TickerDemo {/** * 卖票系统 * @param args */public static void main(String[] args) {// TODO Auto-generated method stubTicker ticker =new Ticker();Thread ticker1=new Thread(ticker);Thread ticker2=new Thread(ticker);Thread ticker3=new Thread(ticker);Thread ticker4=new Thread(ticker);ticker1.start();ticker2.start();ticker3.start();ticker4.start();}}

运行结果：

1、同步代码块

使用关键字synchronized

语法：

synchronized（expr）{

statements

}

expr必须为对象的引用，如果对象已经被另一个线程锁定，则在解锁前，该线程将被阻塞。

同步前提：

1、必须要有两个或者以上线程

2、必须是多个线程使用同一个锁

必须保证同步后只有一个线程在运行

好处：解决了多线程安全问题

弊端：消耗了资源

同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。

同步函数是用的哪个锁呢？

函数都有自己所属的对象this，所以同步函数所使用的锁就是this锁。

当同步函数被static修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。

这个对象就是 类名.class

同步代码块和同步函数的区别？

同步代码块使用的锁可以是任意对象。

同步函数使用的锁是this，静态同步函数的锁是该类的字节码文件对象。

在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。

单例设计模式：（懒汉式延迟加载）

使用双重判断提高效率

public 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;}}

线程间通信：

线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。

等待唤醒机制：涉及的方法：

wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。

notify：唤醒线程池中某一个等待线程。

notifyAll:唤醒的是线程池中的所有线程。

注意：

1：这些方法都需要定义在同步中。

2：因为这些方法必须要标示所属的锁。

     你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中，只能A锁的notify唤醒。

3：这三个方法都定义在Object类中。为什么操作线程的方法定义在Object类中？

     因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用，而锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。

wait和sleep区别： 分析这两个方法：从执行权和锁上来分析：

wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。

sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。

wait：线程会释放执行权，而且线程会释放锁。

Sleep：线程会释放执行权，但不是不释放锁。

线程的停止：通过stop方法就可以停止线程。但是这个方式过时了。

停止线程：原理就是：让线程运行的代码结束，也就是结束run方法。

怎么结束run方法？一般run方法里肯定定义循环。所以只要结束循环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

interrupt()：中断线程。

setPriority(int newPriority)：更改线程的优先级。

getPriority()：返回线程的优先级。

toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。

setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

join：临时加入一个线程的时候可以使用join方法。

当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

模拟一个火车站卖票程序,需求5个窗口,需要多线程完成

public class ticker {private static int tic=100;private String number;public String getNumber() {return number;}public void setNumber(String number) {this.number = number;}public static void setTic(int tic) {ticker.tic = tic;}public ticker(int tic){this.tic=tic;}public static int getTicy(){return tic--;}public static boolean getTic(){if(tic>0)return true;return false;}}public class window implements Runnable{private String name;public window(String name){this.name=name;}public window(){}public String getName() {return name;}public void setName(String name) {this.name = name;}public void run(){while(true){synchronized(window.class){if(ticker.getTic()){try {Thread.sleep(200);System.out.println("第："+Thread.currentThread().getName()+"号窗口卖出了第："+ticker.getTicy()+"号票！");} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}elsebreak;}}}}public class tickDemo {public static void main(String[] args) {// TODO Auto-generated method stubticker tr=new ticker(200);for(int i = 1 ; i <= 5; i ++){new Thread(new window(String.valueOf(i))).start();}}}

运行结果：