多线程详解第3讲：线程状态

比眉伴天荒 2021-09-07 11:36 366阅读 0赞

## 线程状态 ##

--------------------

### 目录 ###

*   *  线程状态
     *   *  1、 五大状态
         *  2、线程方法
         *  3、停止线程
         *  4、线程休眠
         *  5、线程礼让
         *  6、Join
         *  7、线程状态观测
         *  8、线程优先级
         *  9、守护(daemon)线程

### 1、 五大状态 ###

**五大状态**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70]  
**线程状态转换**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 1]

### 2、线程方法 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 2]

### 3、停止线程 ###

**停止线程**

*  不推荐使用JDK提供的 stop()、 destroy()方法。【已废弃】
 *  推荐线程自己停止下来
 *  建议使用一个标志位进行终止变量 ，当flag=false，则终止线程运行。

**代码**

package com.kaung.state;
    
    public class TestStop implements Runnable{ 
        //1.设置一个标识位
        private  boolean flag = true;
        @Override
        public void run() { 
            int i = 0;
            while(flag){ 
                System.out.println("run.....Thread"+i++);
            }
        }
        //2.设置一个公开的方法停止线程，转换标志位
        public void stop(){ 
            this.flag = false;
        }
    
        public static void main(String[] args) { 
    
            TestStop testStop = new TestStop();
            new Thread(testStop).start();
    
            for (int i = 0; i < 1000; i++) { 
                System.out.println("main"+i);
                if(i==900){ 
                    //调用stop方法切换标志位，让线程停止
                    testStop.stop();
                    System.out.println("线程停止了");
                }
            }
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 3]

### 4、线程休眠 ###

**线程休眠**

*  sleep (时间) 指定当前线程阻塞的毫秒数； 1000 ms = 1s
 *  sleep存在异常InterruptedException；
 *  sleep时间达到后线程进入就绪状态；
 *  sleep可以模拟网络延时，倒计时等。
 *  每一个对象都有一个锁，sleep不会释放锁；

**演示代码**

模拟网络延时：放大问题的发生性。

package com.kaung.state;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.logging.SimpleFormatter;
    
    //模拟倒计时
    public class TestSleep { 
    
        public static void main(String[] args) { 
            //打印系统当前时间
            Date startTime = new Date(System.currentTimeMillis()); //获取系统当前时间
    
            while(true){ 
                try { 
                    Thread.sleep(1000);
                    System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                    startTime = new Date(System.currentTimeMillis()); //更新时间
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
        //模拟倒计时
        public static void tenDown() throws InterruptedException { 
            int num = 10;
            while(true) { 
                Thread.sleep(1000);
                System.out.println(num--);
                if(num<=0){ 
                    break;
                }
            }
        }
    }

### 5、线程礼让 ###

**线程礼让**

*  礼让线程，让当前正在执行的线程暂停，但不阻塞
 *  将线程从运行状态转为就绪状态
 *  **让cpu重新调度，礼让不一定成功！看CPU心情**

**代码模拟**

package com.kaung.state;
    
    public class TestYield { 
        public static void main(String[] args) { 
            MyYield myYield = new MyYield();
            new Thread(myYield,"a").start();
            new Thread(myYield,"b").start();
    
        }
    }
    
    class MyYield implements Runnable{ 
    
        @Override
        public void run() { 
            System.out.println(Thread.currentThread().getName()+"线程开始执行");
            Thread.yield();//线程礼让
            System.out.println(Thread.currentThread().getName()+"线程停止执行");
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 4]  
**总结**

礼让不一定成功，需要看cpu心情。

### 6、Join ###

**Join**

*  Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
 *  可以想象成插队  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 5]  
    **代码模拟**

package com.kaung.state;
    
    
    //测试join方法，想象成插队
    public class TestJoin implements Runnable{ 
        @Override
        public void run() { 
            for (int i = 0; i < 1000; i++) { 
                System.out.println("线程VIP来了"+i);
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
    
            //启动我们的线程
            TestJoin testJoin = new TestJoin();
            Thread thread = new Thread(testJoin);
            thread.start();
    
            for (int i = 0; i < 500; i++) { 
                if(i==200){ 
                    thread.join();
                }
                System.out.println("main"+i);
            }
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 6]

### 7、线程状态观测 ###

**JDk帮助文档**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 7]  
**观察线程状态**

package com.kaung.state;
    
    //观测线程的状态
    public class TestState { 
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(()->{ 
                for (int i = 0; i < 5; i++) {  //让线程睡眠5s
                    try { 
                        Thread.sleep(1000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
                System.out.println("///");
            });
    
            //观察状态
            Thread.State state = thread.getState();
            System.out.println(state); //NEW
    
    
            thread.start();//启动线程
            state = thread.getState();
            System.out.println(state); //RUN
    
            while(state != Thread.State.TERMINATED){  //只要线程不停止，就一直输出状态
                Thread.sleep(100);
                state = thread.getState();
                System.out.println(state);
            }
    
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 8]  
**线程一旦进入死亡状态，就不能再次启动了。**

### 8、线程优先级 ###

**线程优先级**

*  Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
 *  线程的优先级用数字表示，范围从1~10.
    
     *  Thread.MIN\_PRIORITY = 1;
     *  Thread.MAX\_PRIORITY = 10;
     *  Thread.NORM\_PRIORITY = 5;
 *  使用以下方式改变或获取优先级
    
     *  getPriority() . setPriority(int xxx)

优先级的设定建议在start()调度前

**代码**

package com.kaung.state;
    
    //测试线程的优先级
    public class TestPriority { 
        public static void main(String[] args) { 
            //主线程默认优先级
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    
            MyPriority myPriority = new MyPriority();
    
            Thread t1 = new Thread(myPriority,"t1");
            Thread t2 = new Thread(myPriority,"t2");
            Thread t3 = new Thread(myPriority,"t3");
            Thread t4 = new Thread(myPriority,"t4");
    
            //先设置线程的优先级，再启动
            t1.start();
    
            t2.setPriority(1);
            t2.start();
    
            t3.setPriority(4);
            t3.start();
    
            t4.setPriority(Thread.MAX_PRIORITY); //MAX_PRIORITY = 10
            t4.start();
    
    
        }
    }
    
    
    class MyPriority implements Runnable{ 
    
        @Override
        public void run() { 
            //获取线程的优先级
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 9]  
**总结**

**优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度**

### 9、守护(daemon)线程 ###

**守护(daemon)线程**

*  线程分为**用户线程**和**守护线程**
 *  虚拟机必须确保用户线程执行完毕
 *  虚拟机不用等待守护线程执行完毕
 *  如,后台记录操作日志,监控内存,垃圾回收等待…

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 10]  
**代码模拟**

package com.kaung.state;
    
    //测试守护线程
    //上帝守护你
    public class TestDaemon { 
        public static void main(String[] args) { 
            God god = new God();
            You you = new You();
    
            Thread thread = new Thread(god);
            thread.setDaemon(true); //默认是false表示的是用户线程，正常的线程都是用户线程
    
            thread.start();//上帝守护线程启动
    
            new Thread(you).start(); //你 用户线程启动...
        }
    }
    
    //上帝
    class God implements Runnable{ 
    
        @Override
        public void run() { 
            while(true){ 
                System.out.println("上帝守护你！");
            }
        }
    }
    
    //你
    class You implements Runnable{ 
    
        @Override
        public void run() { 
            for (int i = 0; i < 36500; i++) { 
                System.out.println("你一生都开心的活着");
            }
            System.out.println("======goodbye world!======"); //hello world
        }
    }

**运行结果**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 11]  
**多线程详解系列文章目录**

[多线程详解第1讲：线程简介][1]

[多线程详解第2讲：线程实现（重点）][2]

[多线程详解第3讲：线程状态][3]

[多线程详解第4讲：线程同步（重点）][4]

[多线程详解第5讲：线程协作][5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70]: /images/20210724/6ca73bbc01b84b1eafd82b7f70fcf110.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 1]: /images/20210724/1b7bca9fe51e412abdfa1b30e7988a93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 2]: /images/20210724/cb00fe8d509240ee9d095649e7b1db7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 3]: /images/20210724/072bcf2810f144dcaa995087b444fc54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 4]: /images/20210724/be1bd2c628764203bebadbc13f444da1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 5]: /images/20210724/c792e43afee24936ad0c6a4219540cd4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 6]: /images/20210724/5ed40378fe35490eb35a131bae5306f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 7]: /images/20210724/5c01a3218d134c229fdde0e177c8cba3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 8]: /images/20210724/2f33c1a64fc14faf9e4fc0e1b91c6b66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 9]: /images/20210724/5f0cf6c1e2cc45408eccfc2b7002c9bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 10]: /images/20210724/6285e598f4774a739e790695d9dd12f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 11]: /images/20210724/9b283554debd4d31a3b8c4aafee63e2d.png
[1]: https://blog.csdn.net/weixin_45629285/article/details/116034361
[2]: https://blog.csdn.net/weixin_45629285/article/details/116034464
[3]: https://blog.csdn.net/weixin_45629285/article/details/116064500
[4]: https://blog.csdn.net/weixin_45629285/article/details/116065351
[5]: https://blog.csdn.net/weixin_45629285/article/details/116065982