java并发编程--- stop() 和 interrupt() 方法的主要区别

我会带着你远行 2022-11-22 05:17 15阅读 0赞

# stop() 和 interrupt() 方法的主要区别 #

---
    title: java并发编程--- stop() 和 interrupt() 方法的主要区别
    date: 2020-11-03 16:33:38
    ---

stop() 方法会真的杀死线程，不给线程喘息的机会，如果线程持有 ReentrantLock 锁，被 stop() 的线程并不会自动调用 ReentrantLock 的 unlock() 去释放锁，那其他线程就再也没机会获得 ReentrantLock 锁，这实在是太危险了。所以该方法就不建议使用了，类似的方法还有 suspend() 和 resume() 方法，这两个方法同样也都不建议使用了，所以这里也就不多介绍了。

而 interrupt() 方法就温柔多了，interrupt() 方法仅仅是通知线程，线程有机会执行一些后续操作，同时也可以无视这个通知。被 interrupt 的线程，是怎么收到通知的呢？一种是异常，另一种是主动检测。

当线程 A 处于 WAITING、TIMED\_WAITING 状态时，如果其他线程调用线程 A 的 interrupt() 方法，会使线程 A 返回到 RUNNABLE 状态，同时线程 A 的代码会触发 InterruptedException 异常。上面我们提到转换到 WAITING、TIMED\_WAITING 状态的触发条件，都是调用了类似 wait()、join()、sleep() 这样的方法，我们看这些方法的签名，发现都会 throws InterruptedException 这个异常。这个异常的触发条件就是：其他线程调用了该线程的 interrupt() 方法。

当线程 A 处于 RUNNABLE 状态时，并且阻塞在 java.nio.channels.InterruptibleChannel 上时，如果其他线程调用线程 A 的 interrupt() 方法，线程 A 会触发 java.nio.channels.ClosedByInterruptException 这个异常；而阻塞在 java.nio.channels.Selector 上时，如果其他线程调用线程 A 的 interrupt() 方法，线程 A 的 java.nio.channels.Selector 会立即返回。

上面这两种情况属于被中断的线程通过异常的方式获得了通知。还有一种是主动检测，如果线程处于 RUNNABLE 状态，并且没有阻塞在某个 I/O 操作上，例如中断计算圆周率的线程 A，这时就得依赖线程 A 主动检测中断状态了。如果其他线程调用线程 A 的 interrupt() 方法，那么线程 A 可以通过 isInterrupted() 方法，检测是不是自己被中断了。

# 具体使用 #

## interrupt方法简单说明 ##

@Slf4j(topic = "c.Test12")
    public class Test12 { 
    
        public static void main(String[] args) throws InterruptedException { 
            Thread t1 = new Thread(() -> { 
                while(true) { 
                    boolean interrupted = Thread.currentThread().isInterrupted();
                    if(interrupted) { 
                        log.debug("被打断了, 退出循环");
                        break;
                    }
                }
            }, "t1");
            t1.start();
    
            Thread.sleep(1000);
            log.debug("interrupt");
            t1.interrupt();
        }
    }

## interrupt使用之优雅打断线程 ##

@Slf4j(topic = "c.TestTwoPhaseTermination")
    public class TestTwoPhaseTermination { 
        public static void main(String[] args) throws InterruptedException { 
            TPTVolatile t = new TPTVolatile();
            t.start();
    
            Thread.sleep(3500);
            log.debug("stop");
            t.stop();
        }
    }
    @Slf4j(topic = "c.TPTInterrupt")
    class TPTInterrupt { 
        private Thread thread;
    
        public void start(){ 
            thread = new Thread(() -> { 
                while(true) { 
                    Thread current = Thread.currentThread();
                    if(current.isInterrupted()) { 
                        log.debug("料理后事");
                        break;
                    }
                    try { 
                        Thread.sleep(1000);
                        log.debug("将结果保存");
                    } catch (InterruptedException e) { 
                        current.interrupt();//----捕获异常之后重新设置中断标志位
                    }
    
                }
            },"监控线程");
            thread.start();
        }
    
        public void stop() { 
            thread.interrupt();
        }
    }
    @Slf4j(topic = "c.TPTVolatile")
    class TPTVolatile { 
        private Thread thread;
        private volatile boolean stop = false;
    
        public void start(){ 
            thread = new Thread(() -> { 
                while(true) { 
                    Thread current = Thread.currentThread();
                    if(stop) { 
                        log.debug("料理后事");
                        break;
                    }
                    try { 
                        Thread.sleep(1000);
                        log.debug("将结果保存");
                    } catch (InterruptedException e) { 
                    }
                }
            },"监控线程");
            thread.start();
        }
    
        public void stop() { 
            stop = true;
            thread.interrupt();
        }
    }