美文网首页Java-多线程
Java并发编程 线程生命周期

Java并发编程 线程生命周期

作者: 香沙小熊 | 来源:发表于2020-12-22 18:29 被阅读0次
    • 有哪6种状态?
    • 每个状态是什么含义
    • 状态间的转化图示
    • 阻塞状态是什么
    每个状态是什么含义
    • New
    • Runnable
    • Blocked
    • Waiting
    • Timed Waiting
    • Terminated

    https://www.jianshu.com/p/dfdc150a3e54

    image.png
    展示线程的NEW、RUNNABLE、Terminated状态
    /**
     * 描述:     展示线程的NEW、RUNNABLE、Terminated状态。即使是正在运行,也是Runnable状态,而不是Running。
     */
    public class NewRunnableTerminated implements Runnable {
    
        public static void main(String[] args) {
            Thread thread = new Thread(new NewRunnableTerminated());
            //打印出NEW的状态
            System.out.println(thread.getState());
            thread.start();
            System.out.println(thread.getState());
            try {
                Thread.sleep(6);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //打印出RUNNABLE的状态,即使是正在运行,也是RUNNABLE,而不是RUNNING
            System.out.println(thread.getState());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //打印出TERMINATED状态
            System.out.println(thread.getState());
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println(i);
            }
        }
    }
    
    NEW
    RUNNABLE
    0
    1
    2
    ... 省略
    294
    295
    RUNNABLE
    296
    297
    298
    ... 省略
    998
    999
    TERMINATED
    
    Process finished with exit code 0
    
    
    展示Blocked, Waiting, TimedWaiting
    /**
     * 描述:     展示Blocked, Waiting, TimedWaiting
     */
    public class BlockedWaitingTimedWaiting implements Runnable{
        public static void main(String[] args) {
            BlockedWaitingTimedWaiting runnable = new BlockedWaitingTimedWaiting();
            Thread thread1 = new Thread(runnable);
            thread1.start();
    
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            Thread thread2 = new Thread(runnable);
            thread2.start();
    
            //打印出Timed_Waiting状态,因为正在执行Thread.sleep(1000);
            System.out.println(thread1.getState());
            //打印出BLOCKED状态,因为thread2想拿得到sync()的锁却拿不到
            System.out.println(thread2.getState());
            try {
                Thread.sleep(1300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //打印出WAITING状态,因为执行了wait()
            System.out.println(thread1.getState());
    
        }
    
        @Override
        public void run() {
            syn();
        }
    
        private synchronized void syn() {
            try {
                Thread.sleep(1000);
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    TIMED_WAITING
    BLOCKED
    WAITING
    
    阻塞状态

    一般习惯而言,把Blocked(被阻塞)、Waiting(等待)、Timed_waiting(即使等待)都成为阻塞状态

    • 不仅仅是Blocked

    特别感谢

    悟空

    相关文章

      网友评论

        本文标题:Java并发编程 线程生命周期

        本文链接:https://www.haomeiwen.com/subject/zhbsnktx.html