Java如何关闭线程

大家都知道Thread类的stop方法已经为过期方法，下面提供一个优雅关闭线程的方法和强制关闭线程的方法。Worker和Thread类的test2方法是测试优雅关闭，另外一个是强制关闭。

Worker

package cn.zxw.test.thread;

/**
* @author 华安小书童
* @description 通过标识关闭线程
* @data: 2020/4/1 11:50
*/
public class Worker extends Thread {

   private volatile boolean flag = true;

   @Override
   public void run() {
       while (flag) {
           System.out.println("do someThink");
       }
   }

   public void shutdown() {
       flag = false;
   }
}

ThreadService

package cn.zxw.test.thread;

/**
 * @author 华安小书童
 * @description 执行线程，以及打断线程
 * @data: 2020/4/1 11:12
 */
public class ThreadService {

    /**
     * 执行传入线程的线程
     */
    private Thread executeThread;

    /**
     * 任务是否执行成功标识
     */
    private boolean finished = false;

    /**
     * 执行传入线程
     *
     * @param task 传入执行线程
     */
    public void execute(Runnable task) {
        executeThread = new Thread(() -> {
            Thread innerThread = new Thread(task);
            //设置为守护线程，当外层的线程执行完，它就会结束
            innerThread.setDaemon(true);
            innerThread.start();
            try {
                //当里面的线程执行完毕后才会执行外层的线程
                innerThread.join();
                finished = true;
                System.out.println("加载完毕");
            } catch (InterruptedException e) {
                System.out.println("任务超时，executeThread被打断");
            }
        });
        executeThread.start();
    }

    /**
     * 打断执行线程
     *
     * @param mills 超时时间
     */
    public void shutdown(long mills) {
        long currentTime = System.currentTimeMillis();
        while (!finished) {
            //如果传入线程没有执行完
            if ((System.currentTimeMillis() - currentTime) >= mills) {
                System.out.println("任务超时，结束任务！");
                //如果线程执行时间超过了执行时间，则打断当前线程，传入线程自然就会停止
                executeThread.interrupt();
                break;
            }
            try {
                //如果时间没有超时，让当前线程先等一下
                Thread.sleep(1);
            } catch (InterruptedException e) {
                //当前线程的调用者结束，自己也会结束
                System.out.println("执行线程被打断");
                break;
            }
        }
        finished = false;
    }
}

测试类

package cn.zxw.test.thread;

/**
 * @author 华安小书童
 * @description 线程测试
 * @data: 2020/4/1 11:30
 */
public class ThreadTest {

    public static void main(String[] args) {
        boolean odd = isOdd(-3);
        System.out.println(odd);
    }

    public static void test() {
        ThreadService service = new ThreadService();
        long startTime = System.currentTimeMillis();
        service.execute(() -> {
//            while (true){
//                //模拟加载一个大文件，需要很长时间
//            }
            try {
                //假设加载文件5秒就完成
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //如果超过8秒没有加载完，线程就会结束
        service.shutdown(8_000);
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
    }

    private static void test2() {
        Worker worker = new Worker();
        worker.start();
        try {
            //如果三秒没有执行完，进行关闭
            Thread.sleep(3_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        worker.shutdown();
    }

    private static boolean isOdd(int num) {
        return (num & 1) == 1;
    }
}