Java 多线程（三）—— 线程的生命周期及方法
这篇博客介绍线程的生命周期。
线程是一个动态执行的过程，它也有从创建到死亡的过程。
线程的几种状态
在 Thread 类中，有一个枚举内部类：
上面的信息以图片表示如下：
第一张图：
第二张图：把等待、计时等待、阻塞看成阻塞一个状态了
1、新建状态（new）:使用 new 创建一个线程，仅仅只是在堆中分配了内存空间
新建状态下，线程还没有调用 start()方法启动，只是存在一个线程对象而已
Thread t = new Thread();//这就是t线程的新建状态
2、可运行状态（runnable）：新建状态调用 start() 方法，进入可运行状态。而这个又分成两种状态，ready 和 running，分别表示就绪状态和运行状态
就绪状态：线程对象调用了 start() 方法，等待 JVM 的调度，（此时该线程并没有运行）
运行状态：线程对象获得 JVM 调度，如果存在多个 CPU，那么运行多个线程并行运行
注意：线程对象只能调用一次 start() 方法，否则报错：illegaThreadStateExecptiong
3、阻塞状态（blocked）:正在运行的线程因为某种原因放弃 CPU，暂时停止运行，就会进入阻塞状态。此时 JVM 不会给线程分配 CPU，知道线程重新进入就绪状态，才有机会转到 运行状态。
注意：阻塞状态只能先进入就绪状态，不能直接进入运行状态
阻塞状态分为两种情况：
①、当线程 A 处于可运行状态中，试图获取同步锁时，却被 B 线程获取，此时 JVM 把当前 A 线程放入锁池中，A线程进入阻塞状态
②、当线程处于运行状态时，发出了 IO 请求，此时进入阻塞状态
4、等待状态（waiting）:等待状态只能被其他线程唤醒，此时使用的是无参数的 wait() 方法
①、当线程处于运行状态时，调用了 wait() 方法，此时 JVM 把该线程放入等待池中
5、计时等待（timed waiting）:调用了带参数的 wait（long time）或 sleep(long time) 方法
①、当线程处于运行状态时，调用了带参数 wait 方法，此时 JVM 把该线程放入等待池中
②、当前线程调用了 sleep(long time) 方法
6、终止状态（terminated）:通常称为死亡状态，表示线程终止
①、正常终止，执行完 run() 方法，正常结束
②、强制终止，如调用 stop() 方法或 destory() 方法
③、异常终止，执行过程中发生异常
线程的方法
1、sleep(long millis)
线程休眠：让执行的线程暂停一段时间，进入计时等待状态。
static void sleep(long millis):调用此方法后，当前线程放弃 CPU 资源，在指定的时间内，sleep 所在的线程不会获得可运行的机会，此状态下的线程不会释放同步锁。
该方法更多的是用来模拟网络延迟，让多线程并发访问同一资源时的错误效果更加明显。
2、wait()
线程等待：一旦一个线程执行到wait(),就释放当前的锁。
注意：此方法必须在同步代码块或同步方法中
3、notify()/notifyAll()
唤醒：唤醒wait的一个或所有的线程
注意：此方法需和wait()成对使用，必须在同步代码块或同步方法中
注意sleep()和 wait() 的区别，sleep指定时间内当前线程放弃 CPU 资源，线程不会释放同步锁，wait 会放弃 CPU 资源，同时也会放弃 同步锁
4、join()
联合线程：表示这个线程等待另一个线程完成后（死亡）才执行，join 方法被调用之后，线程对象处于阻塞状态。写在哪个线程中，哪个线程阻塞
这种也称为联合线程，就是说把当前线程和当前线程所在的线程联合成一个线程
5、yield()
礼让线程：表示当前线程对象提示调度器自己愿意让出 CPU 资源。
调用该方法后，线程对象进入就绪状态，所以完全有可能：某个线程调用了 yield() 方法，但是线程调度器又把它调度出来重新执行。
sleep() 和 yield() 方法的区别：
①、都能使当前处于运行状态的线程放弃 CPU资源，把运行的机会给其他线程
②、sleep 方法会给其他线程运行的机会，但是不考虑其他线程优先级的问题；yield 方法会优先给更高优先级的线程运行机会
③、调用 sleep 方法后，线程进入计时等待状态，调用 yield 方法后，线程进入就绪状态。
join示例：
public class TestThread1 { public static void main(String [] args){ SubThread1 subThread1=new SubThread1(); subThread1.start(); for (int i=0;i<=100;i++){ System.out.println(Thread.currentThread().getName()+":"+i); if(i==20){ try { subThread1.join(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } class SubThread1 extends Thread{ @Override public void run(){ for (int i=0;i<=100;i++){ try { Thread.currentThread().sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+":"+i); } } }
运行结果：
main:0 main:1 main:2 main:3 main:4 main:5 main:6 main:7 main:8 main:9 main:10 Thread-0:0 Thread-0:1 Thread-0:2 Thread-0:3 Thread-0:4 Thread-0:5 Thread-0:6 Thread-0:7 Thread-0:8 Thread-0:9 Thread-0:10 . . . Thread-0:99 Thread-0:100 main:11 main:12 main:13 main:14 main:15 . . main:98 main:99 main:100
运行结果分析：在main线程中调用线程A的join()方法，此时main线程停止执行，直至A线程执行完毕，main线程再接着join()之后的代码执行
线程的通信
/** * @author: ChenHao * @Description:使用两个线程打印1-100，线程1，线程2交替打印 * 线程通信：如下的三个关键字使用的话，都得在同步代码块或同步方法中。 * wait():一旦一个线程执行到wait(),就释放当前的锁。 * notify()/notifyAll():唤醒wait的一个或所有的线程 * 如果不使用break，程序将不会停止 * @Date: Created in 10:50 2018/10/29 */ public class TestPrintNum { public static void main(String [] args){ PrintNum printNum=new PrintNum(); Thread thread1=new Thread(printNum); Thread thread2=new Thread(printNum); thread1.start(); thread2.start(); } } class PrintNum implements Runnable{ int num=1; @Override public void run(){ while (true){ synchronized (this){ notify(); if(num<=100){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+":"+num++); }else { break; } try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } }
运行结果：
Thread-0:1 Thread-1:2 Thread-0:3 Thread-1:4 Thread-0:5 Thread-1:6 Thread-0:7 Thread-1:8 Thread-0:9 Thread-1:10 . . .
运行结果分析：当第一个线程获取锁之后，打印后wait,释放锁；第二个线程获取锁，并唤醒第一个线程，打印后wait；交替打印
