我所知道并发编程之线程的状态以及各状态之间的转换详解

一、线程的状态

---

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

参考资料

---

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