JAVA多线程:线程创建过程以及生命周期总结

1）如果所有的前台线程死亡，那么后台线程也会自动死亡。

2）一旦线程A调用了线程B的join()方法，那么线程B将会启动执行。此时，线程A会等待线程B执行完成后再继续执行。

     应用场景： 可以将大任务分而治之，同时又保证了正确的处理顺序！

3）当你改变了一个线程的优先级，那么由这个线程创建的子线程的优先级默认都是这个线程的优先级。默认每个线程的优先级都和创建它的父线程优先级相同。

      线程优先级1~10.默认是5；

4）sleep()和yeild()会使得当前线程暂停，但不会释放同步监视器。而wait()函数会释放同步监视器。使用notify()和notifyAll()唤醒线程。前者唤醒任一线程，后者唤醒所有线程。（两者都是当当前线程放弃了同步监视器，才能去唤醒线程队列里的其它的线程！）

     sleep()回到阻塞状态，yeild()回到就绪状态；

5）当系统中不存在隐式的同步监视器（即是：程序不使用synchornized方法或者代码块保证同步），那么就不能够使用wait()、sleep()和yeild()方法进行线程通信了！

同时notify/notifyAll方法调用后，并不会马上释放监视器锁，而是在相应的synchronized(){}/synchronized方法执行结束后才自动释放锁。

//隐式的同步监视器
synchronized ---> wait(),notify(),notifyAll();

 //Condition实例化一个对象绑定到一个lock对象上
condition   ----->await(),signal(),signalAll();  

---

6）当当前线程执行sleep()之后进入阻塞状态，在此之间（设定的时间），此线程无法执行。即是没有其他线程在执行，CPU空闲，该线程也不会执行。知道经过阻塞时间之后，才会转入就绪状态（runnable）；运行中的线程调用了yeild()函数之后，会转为就绪状态。只有优先级大于或者等于此线程的线程才会被调度器调度执行。（所以完全有可能某个线程调用yeild()函数暂停一下之后，立即再次获得处理器资源被执行）

---

.Java中的线程的生命周期大体可分为5种状态。

1. 新建(NEW)：新建了一个线程对象。
 

2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

3. 运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。
4. 阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种： 
 

(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
(三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

5. 死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

 

二.初始状态

1.   实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态

三.可运行状态

1.   可运行状态只是说你资格运行，调度程序没有挑选到你，你就永远是可运行状态。

2.   调用线程的start()方法，此线程进入可运行状态。

3.   当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入可运行状态。

4.   当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入可运行状态。

5.   锁池里的线程拿到对象锁后，进入可运行状态。

四.运行状态

1.   线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

五.死亡状态

1.   当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。

2.   在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

3.调用stop(）结束线程，可能会导致死锁。

六.阻塞状态

1.   当前线程T调用Thread.sleep()方法，当前线程进入阻塞状态。

2.   运行在当前线程里的其它线程t2调用join()方法，当前线程进入阻塞状态。

3.   等待用户输入的时候，当前线程进入阻塞状态。

七.等待队列(本是Object里的方法，但影响了线程)

1.   调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。

2.   与等待队列相关的步骤和图

·        线程1获取对象A的锁，正在使用对象A。

·        线程1调用对象A的wait()方法。

·        线程1释放对象A的锁，并马上进入等待队列。

·        锁池里面的对象争抢对象A的锁。

·        线程5获得对象A的锁，进入synchronized块，使用对象A。

·        线程5调用对象A的notifyAll()方法，唤醒所有线程，所有线程进入锁池。||||| 线程5调用对象A的notify()方法，唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入锁池。

·        notifyAll()方法所在synchronized结束，线程5释放对象A的锁。

·        锁池里面的线程争抢对象锁，但线程1什么时候能抢到就不知道了。||||| 原本锁池+第6步被唤醒的线程一起争抢对象锁。

八.锁池状态

1.   当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入锁池状态。简言之，锁池里面放的都是想争夺对象锁的线程。

2.   当一个线程1被另外一个线程2唤醒时，1线程进入锁池状态，去争夺对象锁。

3.   锁池是在同步的环境下才有的概念，一个对象对应一个锁池。

九.几个方法的比较

1.   Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入阻塞，但不释放对象锁，millis后线程自动苏醒进入可运行状态。作用：给其它线程执行机会的最佳方式。

2.   Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的cpu时间片，由运行状态变会可运行状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。

3.   t.join()/t.join(longmillis)，当前线程里调用其它线程1的join方法，当前线程阻塞，等待过程中会释放对象锁，直到线程1执行完毕或者millis时间到，当前线程进入可运行状态。

4.   obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒。

5.   obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。