终于搞懂了线程的状态以及状态转换

1 线程的状态

线程的状态是一个枚举类型 Thread.State
public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}

终于搞懂了线程的状态以及状态转换_第1张图片

  1. 新建(New)

    意义:线程刚刚被创建但尚未开始执行。在这个状态下,线程对象已经被创建,但还没有调用其start()方法来启动线程执行。线程此时不会占用系统资源,只是处于等待被启动的状态。
  2. 就绪(Runnable)

    意义:线程是可工作的。又可以分成正在工作中和即将开始工作,但是没有明确的区分,两种情况下都称之为Runnable。
  3. 阻塞(Blocked)

    意义:线程被阻塞,暂时无法继续执行。这可能是因为线程在等待某个资源(如锁、IO操作、等待其他线程的通知等)而被挂起,无法继续执行任务。
  4. 等待(Waiting)

    意义:线程进入等待状态,等待特定条件的满足。线程会等待,直到其他线程显式地唤醒它或者等待的条件变为真。
  5. 超时等待(Timed Waiting)

    意义:线程进入有限时间的等待状态。与等待状态类似,但可以设置一个超时时间,线程会等待一段时间后自动唤醒。

2 状态转换

2.1NEW RUNNABLE TERMINATED 状态的转换

public class ThreadStateTransfer {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
            }
        }, "thread-1");
        System.out.println(t.getName() + ": " + t.getState());;
        t.start();
        while (t.isAlive()) {
            System.out.println(t.getName() + ": " + t.getState());;
        }
        System.out.println(t.getName() + ": " + t.getState());;
    }
}

终于搞懂了线程的状态以及状态转换_第2张图片

从代码中我们可以清楚的看到线程thread-1从创建到执行完毕自己的“任务”的整个状态转换,NEW-RUNNABLE-TERMINATED。

2.2 WAITING 、 BLOCKED 、 TIMED_WAITING 状态

 首先看一下TIME_WAITING和BOLCKED状态,通过代码的方式来认识一下这两个状态的含义。

public class ThreadStateTransfer2 {
    public static void main(String[] args) {
        final Object object = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    while (true) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("hehe");
                }
            }
        }, "t2");
        t2.start();
    }
}

 在这个代码中线程t1首先获取到锁,然后自己会一直进入休眠(休眠是带有时间上限的,但是又与while的条件实际上是无休止的休眠,单独对于一次休眠等待来说是有时间上限的。)线程t2此时创建并启动但是由于获取不到锁对象,因此进入阻塞状态等待线程t1释放锁对象

使用jconsole工具来查看当前两个线程的状态:

终于搞懂了线程的状态以及状态转换_第3张图片

终于搞懂了线程的状态以及状态转换_第4张图片

那么WAITING状态又是怎么样子的呢?

只需要将上面代码中的t1中的sleep换成wait即可:

public class ThreadStateTransfer2 {
    public static void main(String[] args) {
        final Object object = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                        try {
                            //修改这个sleep
                            //Thread.sleep(1000);
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("hehe");
                }
            }
        }, "t2");
        t2.start();
    }
}

此时线程t1同样是率先获得锁对象,但是不在进行“休眠操作”,而是直接进入等待状态同时放开自己拥有的锁对象,此时的等待是等待拥有此锁对象的其他线程来通知t1结束等待,可惜的是t1永远也等待不到通知(代码中没有写....)。然后t1再启动,这次t1不再进入阻塞状态,因为此时的锁对象被t1所获取到后又通过wait释放了。

通过jconsole来观察此时的t1的状态(waiting):

终于搞懂了线程的状态以及状态转换_第5张图片

而此时t2由于获取到锁对象,进入正常的工作,t2的状态就是RUNNABLE然后会转换成TERMINATED.

那么t1如何从WAITING装换成RUNNABLE呢?只需要线程t2在结束自己的任务后,使用notify来通知t1线程即可。(就是谢谢你t1刚才等待我,让出锁,现在我t2事务工作执行完成了,你t1可以继续执行了)

public class ThreadStateTransfer2 {
    public static void main(String[] args) {
        final Object object = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                        try {
                            //修改这个sleep
                            //Thread.sleep(1000);
                            System.out.println("t1 wait 之前");
                            object.wait();
                            System.out.println("t1 收到了通知");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("t2 工作打印,hehe");
                    object.notify();
                }
            }
        }, "t2");
        t2.start();
        System.out.println("t1 的状态:"+t1.getState());
        System.out.println("t2 的状态:"+t2.getState());

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("t2 的状态:"+t2.getState());
    }
}

终于搞懂了线程的状态以及状态转换_第6张图片

 可以看到t1的状态从WAITING到最终TERMINATED的一个变化。

2.3 yield()----大公无私,让出cpu

public class ThreadYield {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("张三");
                    // 先注释掉, 再放开
                    // Thread.yield();
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("李四");
                }
            }
        }, "t2");
        t2.start();
    }
}

运行以上代码,可以观察到打印出张三、李四的数量大概是五五开,两者同时抢占式执行。

但是使用了yield()之后张三的数量就会远远小于李四,也就是线程t1在yield之后会让出cpu,此时不改变线程的状态,t1的状态一直都是RUNNABLE但是t1回去就绪队列中重新排队。之前说的RUNNABLE包含两种情况,一种是就绪中(可以工作)只是在排队,还有一种就是在执行中。

3 总结

终于搞懂了线程的状态以及状态转换_第7张图片

你可能感兴趣的:(Java,java,开发语言)