Java安全停止线程

Thread 类虽提供了一个 stop() 方法（已经被废弃），但由于 stop() 方法强制终止一个正在执行的线程，可能会造成数据不一致的问题，所以在生产环境中最好不要使用。

场景：

由于一些操作需要轮询处理，且需要保证数据的一致性和完整性。在发布项目时需要安全的结束正在运行的线程才能启动服务。

根据以上场景记录一下安全终止线程的方式：

用 volatile 标记停止线程

使用 volatile 作为标记位的核心就是他的可见性特性，线程的中根据这个标记判断是否退出，通常这种情况一般是在 run 方法中循环执行的。

项目启动时启动要做轮询的线程

@Component
public class ServerBootstrapListener implements ApplicationListener<ApplicationStartedEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartedEvent applicationStartedEvent) {
        System.out.println("ServerBootstrapListener.......");
        DemoRunnable demoRunnable = new DemoRunnable();
        new Thread(demoRunnable, "DemoRunnable").start();
    }


}

 线程执行逻辑

public class DemeRunnable implements Runnable {
    
    // 退出标识
    private static volatile boolean isClose = true;

    @Override
    public void run() {
        while (isClose) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            log.info("线程执行中....");
        }

        log.info("isClose：{}，线程结束.", isClose);
    }

    public static void isClose() {
        isClose = false;
    }
}

通过访问当前地址安全的结束线程

@GetMapping(value = "/close")
void close() {
    DemoRunnable.isClose();
}

在一些特殊场景使用 volatile 时是有一个的风险的，所以建议使用下边使用，关于【volatile 修饰标记位不适用的场景】请自行查找。

使用 interrupt 终止线程

Thread.java类中提供了两种方法：

• this.interrupted(): 测试当前线程是否已经中断；
• this.isInterrupted(): 测试线程是否已经中断；

interrupt() 方法本身是不会终止线程的，需要一个间接接实现的方式终止线程。

为什么说是简接实现呢？因为线程执行 interrupt() 方法并不会直接终止线程。

简单分析一下 interrupt() 实现安全终止线程的过程：

首先，当执行线程的 interrupt() 方法后，就会给该线程打上一个中断的标识属性，有点类似 volatitle 变量的可见性玩法。通过这样的可见性变量，我们就可以设置某种状态，当满足该状态时就结束线程。

接下来根据 isInterrupted() 方法获取到中断标识属性的状态值，就可以判断是否束该线程。

 

项目启动时启动要做轮询的线程

@Component
public class ServerBootstrapListener implements ApplicationListener<ApplicationStartedEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartedEvent applicationStartedEvent) {
        System.out.println("ServerBootstrapListener.......");

        DemoRunnable two = new DemoRunnable();
        Thread thread = new Thread(two, "DemoRunnable");

        thread.start();

        two.setCurrentThread(thread);

    }

}

线程执行逻辑

@Slf4j
public class DemoRunnable implements Runnable {

    private static Thread currentThread;

    @SneakyThrows
    @Override
    public void run() {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("线程已经终止，循环不再执行");
                return;
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("线程执行中....");
        }

    }

    public static Thread getCurrentThread() {
        return currentThread;
    }

    public void setCurrentThread(Thread currentThread) {
        DemoRunnable.currentThread = currentThread;
    }
}

 通过访问当前地址安全的结束线程

@GetMapping(value = "/close")
void close() {
    Thread currentThread = DemoRunnable.getCurrentThread();
    currentThread.interrupt();
}

总结

通过上面的介绍线程终止的两种方式，一种是 interrupt 一种是 volatile ，两种类似的地方都是通过标记来实现的， interrupt 是中断信号传递，基于系统层次的，不受阻塞影响，而对于 volatile 是利用其可见性而顶一个标记位标量，但是当出现阻塞等时无法进行及时通知。

在我们平时的开发中，我们视情况而定，在一般情况下都是可以使用 volatile ，但是这需要我们精确的掌握其中的场景。