一、线程的状态
首先咱们的线程被创立进去之后，它并不是会立即执行，而是由多个线程进行抢占CPU资源，那么，哪一个线程抢占到了，那一个线程就来执行。
就像之前讲的烤烧饼的例子一样，炉子下面有多个工作在转，转到哪个工作（烧饼），那么那个工作就执行。
也就是说，在这个过程中，波及到线程的生命周期的问题，就是说，从线程的创立到线程的完结的这个过程，它所经验的各个阶段，即线程的状态
那么能够说，线程从创立到死亡，能够说有七个状态
第一个：初始化状态
咱们把它称之为实例化，也就是所谓的初始化状态，那么，初始化状态调用了start()办法，start()办法是启动一个线程
第二个：就绪状态
当启动线程后变成了ready to run，然而ready to run并不是run，而是一个筹备运行状态，它也是属于就绪状态
第三个：运行中状态
当线程处于就绪状态时，如果此时它抢到了CPU资源，就变成了运行状态，就是运行中状态（Running）
第四个：终止阶段
那么运行中的线程失常运行结束之后就完结了，就是Dead也就是所谓的终止阶段，死亡阶段，阐明这个过程就失常完结了，这就是一个残缺的生命周期
第五个：阻塞状态
阻塞状态是线程因为某种原因放弃CPU的使用权，临时进行运行
第六个：期待状态
当线程当正处于运行状态的时候，忽然调用wait办法，于是就到了期待状态，或者当正处于运行状态的时候，遇到了IO的阻塞或进入到一个同步代码块，于是在里面期待
第七个：超时期待状态
当线程当正处于运行状态的时候，忽然调用sleep办法，于是就睡觉了
然而当肯定工夫过了之后，它就能本人再回到ready to run （就绪状态）去竞争CPU的资源
二、通过代码来模仿线程的几种状态
咱们采纳个别创立线程的形式：实现Runable接口重写Run办法，来新建一个线程
class NewThrad implements Runnable{ @Override public void run() { System.out.println("线程运行起....."); }}首先咱们先在main办法里领会一下第一种初始化状态
public static void main(String[] args) { Thread thread =new Thread(new NewThrad());}这就是所谓的初始化状态，也就是被new进去的时候就是一个初始化状态
public static void main(String[] args) { Thread thread =new Thread(new NewThrad()); thread.start();//启动线程}等咱们调用start()办法之后，就变成了ready to run （就绪状态）它能够去竞争CPU资源
public static void main(String[] args) { Thread thread =new Thread(new NewThrad()); thread.start();//启动线程}运行后果如下：线程运行起.....如果抢到了CPU资源，就变成Running而后输入进去，接下来咱们增加多一个主线程来领会
class NewThrad implements Runnable{ @Override public void run() { while(true){ System.out.println("自定义程执行起来...."); } }}public static void main(String[] args) { Thread thread =new Thread(new NewThrad()); thread.start();//启动线程 while(true){ System.out.println("主线程执行起来...."); }}运行后果如下：主线程执行起来....主线程执行起来....自定义程执行起来....自定义程执行起来....有主线程和自定义线程，这两个线程那么就会有两个个处于就绪状态，它们同时去抢夺CPU资源，那么，谁抢到了那么谁就变成了Running，谁没有抢到，那么它仍然就处于ready to run
所以说，咱们发现并不是一个线程抢占了CPU资源之后就一只执行，而是过了一会又被其余线程给抢占了，就是这么一个状况
class NewThrad implements Runnable{ @Override public void run() { while(true){ System.out.println("自定义程执行起来...."); try { //每执行一次就期待1000毫秒 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }}class NewThrad implements Runnable{ @Override public void run() { while(true){ System.out.println("自定义程执行起来...."); try { //每执行一次就期待1000毫秒 Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }}运行后果如下：主线程执行起来....自定义程执行起来....自定义程执行起来....自定义程执行起来....主线程执行起来....这段代码增加Thread.sleep()办法时，咱们的主线程在走到sleep(2000)的时候，这时主线程就会处于sleeping状态，也就是超时期待状态，那么当等待时间完结了之后，接着进入到就绪状态，去抢占CPU资源实现输入
class NewThrad implements Runnable{ @Override public synchronized void run() { while(true){ try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("自定义程执行起来...."); } }}public static void main(String[] args) { NewThrad newThrad = new NewThrad(); Thread thread = new Thread(newThrad); thread.start();//启动线程 while(true){ synchronized (newThrad) { System.out.println("主线程执行起来...."); try { //每执行一次就期待100毫秒 Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } //唤醒newThrad期待线程 newThrad.notifyAll(); } }}运行后果如下：主线程执行起来....主线程执行起来....自定义程执行起来....主线程执行起来....主线程执行起来....这段代码中 NewThrad增加wait()，当调用了wait()办法之后，它会始终处于期待状态，直到主线程调用了notify或者notifyAll之后，它才会处于就绪状态
而后开始争夺CPU资源，如果抢到CPU资源，那么就开始执行，本例中执行完之后又处于wait状态，而后接着主线程执行
参考资料
龙果学院：并发编程原理与实战（叶子猿老师）