6.4 ThreadPoolExecutor线程池的关闭方法shutdown和shutdownNow区别、示例

shutdown():

把线程池的状态设置成SHUTDOWN状态，然后中断所有没有正执行任务的线程

shutdownNow():

首先把线程池的状态设置成STOP,然后尝试停止所有正在执行任务或者暂停任务的线程，并返回等待执行任务的列表

常用

通常我们调用shutdown()方法关闭线程池，如果不需要任务执行完成，可以调用shutdownNow(）

原理

遍历线程池中的工作线程，然后组个调用线程的interrupt方法来中断线程，所以无法响应中断任务的可能永远无法停止

其他方法

isShutdown():

只要调用了shutdown或者shutdownNow，isShutdown就会返回true，否则false

isTerminaed():

当所有任务关闭之后，才表示线程池关闭成功，这时会返回true

isTerminating：

执行了shutdown或shutdownNow之后，还有任务正在进行中=true，没有任务进行中=false

测试示例

测试shutdown

public class Test {
    static class Customer extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "开始执行");
            try {
                //模拟任务执行4s
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行完成");
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                10,
                20,
                20,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(10), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                //1、设置线程的名字
                Thread thread = new Thread(r);
                //thread.setName("通过自定义线程工厂谁知线程名字");
                //2、设置成守护线程
                //thread.setDaemon(true);
                return thread;
            }
        },
                //四种阻塞队列满之后的处理方式
//                new ThreadPoolExecutor.CallerRunsPolicy()); 使用调用线程处理，比如是main调用的线程池，用main线程执行
//                new ThreadPoolExecutor.DiscardOldestPolicy());把阻塞队列首元素丢掉，执行当前线程
//                new ThreadPoolExecutor.DiscardPolicy());直接丢掉当前线程
                new AbortPolicy());//跑出异常

        executor.execute(new Customer());
        Thread.sleep(100);
        //当前线程还未执行完，执行shutdown
        System.out.println("执行shutdown之前");
        System.out.println(executor.isTerminated());
        System.out.println(executor.isShutdown());
        System.out.println(executor.isTerminating());

        executor.shutdown();
        System.out.println("执行shutdown之后，但是还有任务正在执行");
        //线程还没有执行完成，isTerminated()=false
        System.out.println(executor.isTerminated());
        System.out.println(executor.isShutdown());
        System.out.println("有任务进行中isTerminating="+executor.isTerminating());

        //线程执行完成，isTerminated()=true
        Thread.sleep(4000);
        System.out.println("执行shutdown之后，所有任务执行完成");
        System.out.println(executor.isTerminated());
        System.out.println("没有任务进行中isTerminating="+executor.isTerminating());
    }
}

结果

Thread-1开始执行
执行shutdown之前
false
false
false
执行shutdown之后，但是还有任务正在执行
false
true
有任务进行中isTerminating=true
Thread-1执行完成
执行shutdown之后，所有任务执行完成
true
没有任务进行中isTerminating=false

测试shutdownNow

public class Test {
    static class Customer extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "开始执行");
            try {
                //模拟任务执行4s
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行完成");
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                10,
                20,
                20,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(10), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                //1、设置线程的名字
                Thread thread = new Thread(r);
                //thread.setName("通过自定义线程工厂谁知线程名字");
                //2、设置成守护线程
                //thread.setDaemon(true);
                return thread;
            }
        },
                //四种阻塞队列满之后的处理方式
//                new ThreadPoolExecutor.CallerRunsPolicy()); 使用调用线程处理，比如是main调用的线程池，用main线程执行
//                new ThreadPoolExecutor.DiscardOldestPolicy());把阻塞队列首元素丢掉，执行当前线程
//                new ThreadPoolExecutor.DiscardPolicy());直接丢掉当前线程
                new AbortPolicy());//跑出异常

        executor.execute(new Customer());
        Thread.sleep(100);
        //当前线程还未执行完，执行shutdown
        System.out.println("执行shutdown之前");
        System.out.println(executor.isTerminated());
        System.out.println(executor.isShutdown());
        System.out.println(executor.isTerminating());

        executor.shutdownNow();
        System.out.println("执行shutdown之后，但是还有任务正在执行");
        //线程还没有执行完成，isTerminated()=false
        System.out.println(executor.isTerminated());
        System.out.println(executor.isShutdown());
        System.out.println("有任务进行中isTerminating="+executor.isTerminating());

        //线程执行完成，isTerminated()=true
        Thread.sleep(4000);
        System.out.println("执行shutdown之后，所有任务执行完成");
        System.out.println(executor.isTerminated());
        System.out.println("没有任务进行中isTerminating="+executor.isTerminating());
    }
}

结果：因为要中断正在执行的任务，所有会报中断异常

Thread-1开始执行
执行shutdown之前
false
false
false
执行shutdown之后，但是还有任务正在执行
false
true
有任务进行中isTerminating=true
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at cn.enjoyedu.ch6.Test$Customer.run(Test.java:14)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:748)
Thread-1执行完成
执行shutdown之后，所有任务执行完成
true
没有任务进行中isTerminating=false