乐趣区

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

jiezi

一、线程的状态

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

参考资料

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

退出移动版