一、线程的状态
首先咱们的线程被创立进去之后，它并不是会立即执行，而是由多个线程进行抢占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状态，而后接着主线程执行
参考资料
龙果学院：并发编程原理与实战（叶子猿老师）
发表回复