Java多线程（七）线程停止、休眠、礼让和强制执行

秒速五厘米 2022-11-06 15:55 198阅读 0赞

##### 一、线程停止（stop） #####

*  在Java中有3种方法可以停止正在运行的线程:
    
     *  使用退出标志使线程正常终止，也就是当run方法完成后线程终止。
     *  使用**stop**方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend、resume一样，都是过期作废的方法。
     *  使用interrupt方法中断线程。
 *  使用标志位来停止线程：

/** * 使用状态标记来停止线程 */
    public class TestThreadDemo01 implements Runnable{ 
        public static void main(String[] args) throws Exception { 
            TestThreadDemo01 threadDemo01 = new TestThreadDemo01();
            new Thread(threadDemo01).start();
            for (int i=0;i<1000;i++){ 
                System.out.println("主线程"+i);
                if (i==900){ 
                    threadDemo01.stop();
                    System.out.println("线程停止了！");
                    break;
                }
            }
        }
    
        //状态标记
        private boolean flag = true;
    
        @Override
        public void run() { 
            int i = 0;
            while (flag){ 
                System.out.println("线程！" + (i++));
            }
        }
    
        public void stop(){ 
            this.flag = false;
        }
    
    }

*  执行结果如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70]

##### 一、线程休眠 #####

*  总结：
    
     *  sleep（时间）指定当前线程阻塞的毫秒数；
     *  sleep存在异常InterruptedException
     *  sleep时间到达后线程进入就绪状态
     *  sleep可以模拟网络延时，倒计时等。
     *  每一个对象都有一个锁，sleep不会释放锁
 *  代码案例：

/** * 线程休眠 sleep */
    public class TestThreadSleep implements Runnable{ 
        public static void main(String[] args) { 
            TestThreadSleep th1 = new TestThreadSleep();
            new Thread(th1).start();
        }
    
        @Override
        public void run() { 
            //模拟倒计时
            for (int i=10;i>0;i--){ 
                try { 
                    Thread.sleep(1000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(i);
            }
    
        }
    }

*  执行结果如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 1]

##### 一、线程礼让 #####

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

/** * 线程礼让 */
    public class TestThreadComity implements Runnable{ 
        public static void main(String[] args) { 
            TestThreadComity th = new TestThreadComity();
            new Thread(th,"线程1").start();
            new Thread(th,"线程2").start();
        }
    
        @Override
        public void run() { 
            System.out.println(Thread.currentThread().getName()+"开始执行！");
            Thread.yield();
            System.out.println(Thread.currentThread().getName()+"结束执行！");
        }
    }

*  执行结果如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 2]

##### 一、线程强制执行 #####

*  join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
 *  相当于**插队**
 *  代码案例：

/** * 线程强制执行---插队 */
    public class TestThreadJoin implements Runnable { 
    
        public static void main(String[] args) throws Exception { 
            Thread thread = new Thread(new TestThreadJoin());
            for (int i = 0; i < 400; i++) { 
                System.out.println("主线程在排队！！！" + i);
                if (i == 100) { 
                    thread.start();
                    thread.join();
    
                }
            }
        }
    
        @Override
        public void run () { 
            for (int i = 0; i < 100; i++) { 
                System.out.println("VIP线程来插队了！！！" + i);
            }
        }
    }

*  执行结果如下：等待插队线程执行完，才继续执行主线程！  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 3]  
    ***路漫漫其修远兮，吾必将上下求索~***  
    如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧\*\*转载请注明出处哦\*\*

Java多线程扩展：[Java多线程学习汇总][Java]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70]: /images/20221023/4f4b1f6d39e74752b85640d6e93a9dc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 1]: /images/20221023/7d488ea1ae394dc6b32b5b943bf20a5e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 2]: /images/20221023/0d5213f6d6964408984c8d3e63b9f4f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 3]: /images/20221023/0ca6ac389d0041b7b8a4165b7c672802.png
[Java]: https://blog.csdn.net/weixin_43829443/article/details/114359196