并发系列之线程终止

伦敦政治经济学院（英国）校训：“了解万物发生之缘由。”

在实际工作中，当看到代码中有直接new使用线程的话，这是需要警惕的，你手动创建了线程，自然要管理线程的生命周期，这其中必然包含着线程的结束。这是一个容易被忽略的小点，也是面试中高频点，更是实际工作中推荐使用线程池的方式管理线程的缘由。
线程终止有很多方式，这里会介绍工作中推荐使用的终止方式和废弃的方式，以及废弃的原因，了解了这些，才能更好地管理线程。

一推荐方式

常用方式主要有设置退出标识和设置中断标识，有时线程在sleep/join等阻塞的情况下无法根据退出标识进行终止的，这时就需要利用线程的中断机制来优雅地终止线程。具体看下演示demo：

/**
 * @author 阿伦故事
 * @Description：
 *  描述线程安全终止的方式
 *  1 设置exit标识
 *  2 设置中断标识
 * */
@Slf4j
public class ThreadStop {

    //声明内存可见性全局变量
    private volatile boolean flag = false;

    public static void main(String[] args) throws Exception{
        ThreadStop threadStop = new ThreadStop();
        //设置exit标识
        //threadStop.terminByExit();
        //设置中断标识
        threadStop.terminByInter();
    }
    /**
     * way1 ：
     *      设置exit标识
     * */
    public void terminByExit() throws InterruptedException {
        ThreadExit threadExit = new ThreadExit();
        log.info("--开启子线程--");
        threadExit.start();
        Thread.currentThread().sleep(2000);
        flag = true;
        threadExit.join();
        log.info("--stop the world--");
    }
    public class ThreadExit extends Thread{
        @Override
        public void run(){
            while(!flag);
            log.info("--子线程执行完毕--");
        }
    }
    /**
     * way2 ：
     *      设置中断标识
     * */
    public void terminByInter() throws InterruptedException {
        ThreadInter threadInter = new ThreadInter();
        log.info("--开启子线程--");
        threadInter.start();
        Thread.currentThread().sleep(2000);
        flag = true;
        Thread.currentThread().sleep(2000);
        //此时子线程并不会终止，只能通过中断终止
        threadInter.interrupt();
        log.info("--stop the world--");
    }
    public class ThreadInter extends Thread{
        @Override
        public void run(){
            while(!flag){
                try {
                    Thread.currentThread().join();
                } catch (InterruptedException e) {
                    flag = true;
                }
            }
            log.info("--子线程执行完毕--");
        }
    }
}

二废弃方式

1 Thread.stop

此方法已经废弃，主要是因为不安全，它是强行终止线程，非常暴力，可能会带来不可预知的后果；另调用stop之后，创建该子线程的线程就会抛出ThreadDeath的error，具体看下源码：

@Deprecated
    public final void stop() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            checkAccess();
            if (this != Thread.currentThread()) {
                security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
            }
        }
        // A zero status value corresponds to "NEW", it can't change to
        // not-NEW because we hold the lock.
        if (threadStatus != 0) {
            resume(); // Wake up thread if it was suspended; no-op otherwise
        }

        // The VM can handle all thread states
        stop0(new ThreadDeath());
    }

2 suspend & resume

这是必须成对使用的方法，要不很容易造成死锁，在底层都是依赖native方法实现线程的暂停和恢复。如果该线程没有被suspend暂停，则无法通过resume恢复的。
举例一个死锁的场景：线程A持有一把锁，然后A被suspend(不会释放锁)，线程A等待被resume；线程B的执行流程是先获取这把锁，再resume线程A，这样就会造成死锁。

3 Runtime.runFinalizersOnExit

此方法是线程不安全的，它是依赖Shutdown设置终结器(Finalizer)，想深入了解的，具体看下源码：

@Deprecated
    public static void runFinalizersOnExit(boolean var0) {
        SecurityManager var1 = System.getSecurityManager();
        if (var1 != null) {
            try {
                var1.checkExit(0);
            } catch (SecurityException var3) {
                throw new SecurityException("runFinalizersOnExit");
            }
        }

        Shutdown.setRunFinalizersOnExit(var0);
    }

特此声明：
分享文章有完整的知识架构图，将从以下几个方面系统展开：
1 基础（Linux/Spring boot/并发）
2 性能调优（jvm/tomcat/mysql）
3 高并发分布式
4 微服务体系
如果您觉得文章不错，请关注阿伦故事，您的支持是我坚持的莫大动力，在此受小弟一拜！

每篇福利：

评论区打出车型.jpg