叶子猿java并发编程_我所知道并发编程之线程的状态以及各状态之间的转换详解...

一、线程的状态

首先我们的线程被创建出来之后，它并不是会立刻执行，而是由多个线程进行抢占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状态，然后接着主线程执行

参考资料

龙果学院：并发编程原理与实战(叶子猿老师)