多线程入门（2）：如何正确停止线程

我不是女神ヾ 2023-06-27 11:19 2阅读 0赞

# 1 正确停止线程的方式 #

> run方法内没有sleep或wait方法时，停止线程

public class RightWayStopThreadWithoutSleep implements Runnable {
        @Override
        public void run() {
            int num = 0;
            while (!Thread.currentThread().isInterrupted() && num <= Integer.MAX_VALUE / 2) {
                if (num % 10000 == 0) {
                    System.out.println(num + "是10000的倍数");
                }
                num++;
            }
            System.out.println("任务运行结束了");
        }
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new RightWayStopThreadWithoutSleep());
            thread.start();
            Thread.sleep(2000);
            //1073740000
            thread.interrupt();
        }
    }

>  带有sleep的中断线程的写法

public class RightWayStopThreadWithSleep {
        public static void main(String[] args) throws InterruptedException {
            Runnable runnable = () -> {
                int num = 0;
                try {
                    while (num <= 300 && !Thread.currentThread().isInterrupted()) {
                        if (num % 100 == 0) {
                            System.out.println(num + "是100的倍数");
                        }
                        num++;
                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();
            Thread.sleep(500);
            thread.interrupt();
        }
    }

> 如果在执行过程中，每次循环都会调用sleep或wait等方法，那么不需要每次迭代都检查是否已中断

public class RightWayStopThreadWithSleepEveryLoop {
        public static void main(String[] args) throws InterruptedException {
            Runnable runnable = () -> {
                int num = 0;
                try {
                    while (num <= 10000) {
                        if (num % 100 == 0) {
                            System.out.println(num + "是100的倍数");
                        }
                        num++;
                        Thread.sleep(10);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();
            Thread.sleep(5000);
            thread.interrupt();
        }
    }

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

# 2 中断失效！！！ #

> 如果while里面放try/catch，会导致中断失效

public class CantInterrupt {
        public static void main(String[] args) throws InterruptedException {
            Runnable runnable = () -> {
                int num = 0;
                //!Thread.currentThread().isInterrupted()无效
                while (num <= 10000 && !Thread.currentThread().isInterrupted()) {
                    if (num % 100 == 0) {
                        System.out.println(num + "是100的倍数");
                    }
                    num++;
                    try {
                        //sleep过程中收到了中断，响应后interrupt标记为会被清除
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();
            Thread.sleep(5000);
            thread.interrupt();
        }
    }

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

# 3 停止中断的最佳实践 #

> catch了InterruptedExcetion之后的优先选择：在方法签名中抛出异常 那么在run()就会强制try/catch

public class RightWayStopThreadInProd implements Runnable {
        @Override
        public void run() {
            while (true && !Thread.currentThread().isInterrupted()) {
                System.out.println("go");
                try {
                    throwInMethod();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    //保存日志、停止程序
                    System.out.println("保存日志");
                    e.printStackTrace();
                }
            }
        }
        private void throwInMethod() throws InterruptedException {
                Thread.sleep(2000);
        }
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new RightWayStopThreadInProd());
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
        }
    }

> 在catch子语句中调用Thread.currentThread().interrupt()来恢复设置中断状态，以便于在后续的执行中，依然能够检查到刚才发生了中断

public class RightWayStopThreadInProd2 implements Runnable {
        @Override
        public void run() {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("Interrupted，程序运行结束");
                    break;
                }
                reInterrupt();
            }
        }
        private void reInterrupt() {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                //重新设置中断
                Thread.currentThread().interrupt();
                e.printStackTrace();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new RightWayStopThreadInProd2());
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
        }
    }

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

# 4 响应中断的方法总结列表 #

> 1.  Object. wait()/ wait( long)/ wait( long, int)
> 2.  Thread. sleep( long) /sleep( long, int)
> 3.  Thread. join()/ join( long)/ join( long, int)
> 4.  java. util. concurrent. BlockingQueue. take() /put( E)
> 5.  java. util. concurrent. locks. Lock. lockInterruptibly()
> 6.  java. util. concurrent. CountDownLatch. await()
> 7.  java. util. concurrent. CyclicBarrier. await()
> 8.  java. util. concurrent. Exchanger. exchange(V)
> 9.  java.nio.channels.InterruptibleChannel相关方法
> 10. java.nio.channels.Selector的相关方法

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

# 5 Java异常体系  #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

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

# 6 错误的停止方法 #

>  *  被弃用的stop，suspend和resume方法
>  *  用volatile设置boolean标记位

> 为什么`Thread.stop`不推荐使用？[https://docs.oracle.com/javase/7/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html][https_docs.oracle.com_javase_7_docs_technotes_guides_concurrency_threadPrimitiveDeprecation.html]

## 6.1 stop  ##

> 用stop()来停止线程，会导致线程运行一半突然停止，没办法完成一个基本单位的操作（一个连队），会造成脏数据（有的连队多领取少领取装备）。

public class StopThread implements Runnable {
        @Override
        public void run() {
            //模拟指挥军队：一共有5个连队，每个连队10人，以连队为单位，发放武器弹药，叫到号的士兵前去领取
            for (int i = 0; i < 5; i++) {
                System.out.println("连队" + i + "开始领取武器");
                for (int j = 0; j < 10; j++) {
                    System.out.println(j);
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("连队"+i+"已经领取完毕");
            }
        }
        public static void main(String[] args) {
            Thread thread = new Thread(new StopThread());
            thread.start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            thread.stop();
        }
    }

## 6.2 volatile的局限 ##

> 可行

/**
     * 演示用volatile的局限：part1 看似可行
     */
    public class WrongWayVolatile implements Runnable {
        private volatile boolean canceled = false;
        @Override
        public void run() {
            int num = 0;
            try {
                while (num <= 100000 && !canceled) {
                    if (num % 100 == 0) {
                        System.out.println(num + "是100的倍数。");
                    }
                    num++;
                    Thread.sleep(1);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            WrongWayVolatile r = new WrongWayVolatile();
            Thread thread = new Thread(r);
            thread.start();
            Thread.sleep(5000);
            r.canceled = true;
        }
    }

> 一旦线程陷入长时间的阻塞了，这个时候volatile就**废了**
> 
> 生产者会陷入长时间的阻塞，这个时候就不行了 while (num <= 100000 && !canceled)得不到执行

/**
     * 演示用volatile的局限part2 陷入阻塞时，volatile是无法线程的 此例中，生产者的生产速度很快，消费者消费速度慢，所以阻塞队列满了以后，生产者会阻塞，等待消费者进一步消费
     */
    public class WrongWayVolatileCantStop {
        public static void main(String[] args) throws InterruptedException {
            ArrayBlockingQueue storage = new ArrayBlockingQueue(10);
            Producer producer = new Producer(storage);
            Thread producerThread = new Thread(producer);
            producerThread.start();
            Thread.sleep(1000);
    
            Consumer consumer = new Consumer(storage);
            while (consumer.needMoreNums()) {
                System.out.println(consumer.storage.take() + "被消费了");
                Thread.sleep(100);
            }
            System.out.println("消费者不需要更多数据了。");
            //一旦消费不需要更多数据了，我们应该让生产者也停下来，但是实际情况程序并没有停止下来
            producer.canceled = true;
            System.out.println(producer.canceled);
        }
    }
    /**
     * 生产者
     */
    class Producer implements Runnable {
        public volatile boolean canceled = false;
        BlockingQueue storage;
        public Producer(BlockingQueue storage) {
            this.storage = storage;
        }
        @Override
        public void run() {
            int num = 0;
            try {
                while (num <= 100000 && !canceled) {
                    if (num % 100 == 0) {
                        //得不到执行
                        storage.put(num);
                        System.out.println(num + "是100的倍数,被放到仓库中了。");
                    }
                    num++;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("生产者结束运行");
            }
        }
    }
    /**
     * 消费者
     */
    class Consumer {
        BlockingQueue storage;
        public Consumer(BlockingQueue storage) {
            this.storage = storage;
        }
        public boolean needMoreNums() {
            if (Math.random() > 0.95) {
                return false;
            }
            return true;
        }
    }

> 修复上面的问题

/**
     * 用中断来修复刚才的无尽等待问题
     */
    public class WrongWayVolatileFixed {
        public static void main(String[] args) throws InterruptedException {
            WrongWayVolatileFixed body = new WrongWayVolatileFixed();
            ArrayBlockingQueue storage = new ArrayBlockingQueue(10);
    
            Producer producer = body.new Producer(storage);
            Thread producerThread = new Thread(producer);
            producerThread.start();
            Thread.sleep(1000);
    
            Consumer consumer = body.new Consumer(storage);
            while (consumer.needMoreNums()) {
                System.out.println(consumer.storage.take() + "被消费了");
                Thread.sleep(100);
            }
            System.out.println("消费者不需要更多数据了。");
            producerThread.interrupt();
        }
        
        class Producer implements Runnable {
            BlockingQueue storage;
            public Producer(BlockingQueue storage) {
                this.storage = storage;
            }
            @Override
            public void run() {
                int num = 0;
                try {
                    while (num <= 100000 && !Thread.currentThread().isInterrupted()) {
                        if (num % 100 == 0) {
                            storage.put(num);
                            System.out.println(num + "是100的倍数,被放到仓库中了。");
                        }
                        num++;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("生产者结束运行");
                }
            }
        }
        class Consumer {
            BlockingQueue storage;
            public Consumer(BlockingQueue storage) {
                this.storage = storage;
            }
            public boolean needMoreNums() {
                if (Math.random() > 0.95) {
                    return false;
                }
                return true;
            }
        }
    }

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

# 7 分析native层代码  #

> [https://github.com/openjdk-mirror/jdk7u-jdk][https_github.com_openjdk-mirror_jdk7u-jdk]

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

# 8 停止线程相关重要函数解析 #

## 8.1 中断线程 ##

> public void interrupt()

//java.lang.Thread#interrupt
    public void interrupt() {
    	if (this != Thread.currentThread())
    		checkAccess();
    
    	synchronized (blockerLock) {
    		Interruptible b = blocker;
    		if (b != null) {
    			interrupt0();           // Just to set the interrupt flag
    			b.interrupt(this);
    			return;
    		}
    	}
    	interrupt0();
    }

## 8.2 判断是否已被中断相关方法 ##

### 8.2.1 public boolean isInterrupted() ###

> 返回之后不会清除线程中断的状态

//java.lang.Thread#isInterrupted()
    public boolean isInterrupted() {
    	return isInterrupted(false);
    }

### 8.2.2 Thread.interrupted() ###

> 目标对象是当前线程，返回之后会把线程中断状态设为**false**

//java.lang.Thread#interrupted
    public static boolean interrupted() {
    	return currentThread().isInterrupted(true);
    }

## 8.3 coding ##

/**
     * 注意Thread.interrupted()方法的目标对象是“当前线程”，而不管本方法来自于哪个对象
     */
    public class RightWayInterrupted {
        public static void main(String[] args) throws InterruptedException {
            Thread threadOne = new Thread(() -> {
                while (true){}
            });
            // 启动线程
            threadOne.start();
    
            //设置中断标志
            threadOne.interrupt();
            //获取中断标志
            System.out.println("isInterrupted: " + threadOne.isInterrupted());
    
            //获取中断标志并重置(！！会清除中断)
            //public static boolean interrupted() {
            //    true：清除当前的状态
            //    return currentThread().isInterrupted(true);
            //}
            //threadOne.interrupted(); 这样调用也行，但是不规范和Thread.interrupted()效果一样
            Thread.currentThread().interrupt();//main线程被中断
            System.out.println("isInterrupted: " + Thread.interrupted());
            System.out.println("isInterrupted: " + Thread.interrupted());
    
    
            //获取中断标志
            //public boolean isInterrupted() {
            //    false：不清楚中断
            //    return isInterrupted(false);
            //}
            System.out.println("isInterrupted: " + threadOne.isInterrupted());
            threadOne.join();
    
            System.out.println("Main thread is over.");
        }
    }

> isInterrupted: true  
> isInterrupted: true  
> **isInterrupted: false**  
> isInterrupted: true

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

# 9 面试问题  #

> 如何停止线程
> 
> 1.  原理：用**interrupt**来请求、好处
> 2.  想停止线程，要请求方、被停止方、子方法被调用方相互配合
> 3.  最后再说错误的方法：stop/suspend已废弃，volatile的boolean无法处理长时间阻塞的情况

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200117112259181.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[https_docs.oracle.com_javase_7_docs_technotes_guides_concurrency_threadPrimitiveDeprecation.html]: https://docs.oracle.com/javase/7/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html
[https_github.com_openjdk-mirror_jdk7u-jdk]: https://github.com/openjdk-mirror/jdk7u-jdk