ExecutorService中shutdown是啥意思?

Posted 2023-03-18

参考技术A 当线程池调用该方法时,线程池的状态则立刻变成SHUTDOWN状态,以后不能再往线程池中添加任何任务，否则将会抛出RejectedExecutionException异常。但是，此时线程池不会立刻退出，直到添加到线程池中的任务都已经处理完成，才会退出。 与它相似的还有一个shutdownNow()，它通过调用Thread.interrupt来实现线程的立即退出。 参考技术B

ExecutorService中shutdown是的意思如下：

1、当线程池调用该方法时,线程池的状态则立刻变成SHUTDOWN状态,以后不能再往线程池中添加任何任务，否则将会抛出RejectedExecutionException异常。

2、此时线程池不会立刻退出，直到添加到线程池中的任务都已经处理完成，才会退出。

3、 与它相似的还有一个shutdownNow()，它通过调用Thread.interrupt来实现线程的立即退出。

4、ExecutorService是Executor直接的扩展接口，也是最常用的线程池接口，我们通常见到的线程池定时任务线程池都是它的实现类。

5、Executor的实现提供的一些方法可以返回一个 Future ， 通过它我们可以跟踪到异步任务的执行和停止。

6、ExecutorService（线程池）可以被关闭来拒绝新任务。有两个不同的方法来关闭。 shutdown方法 在关闭 ExecutorService 之前等待提交的任务执行完成。

参考技术C shutdown，执行后不再接收新任务，如果里面有任务，就执行完

shutdownNow，执行后不再接受新任务，如果有等待任务，移出队列；有正在执行的，尝试停止之

==========================
通常shutdown之后调用awaitTermination，作用是：后者会阻塞当前线程，等待剩余任务执行完，然后继续往下执行。如果不适用await，那么shutdown之后，很可能导致剩余任务得不到执行（整个程序退出），或是执行出现异常（某些资源被释放之类）。

==========================
例子，网上来的，懒得动手写：
================
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
* Callable 和 Future接口
* Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
* Callable和Runnable有几点不同:
* (1)Callable规定的方法是call(),而Runnable规定的方法是run().
* (2)Callable的任务执行后可返回值(任意类型),而Runnable的任务是不能返回值的。
* (3)call()方法可抛出异常,而run()方法是不能抛出异常的。
* (4)运行Callable任务可拿到一个Future对象,
* Future 表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。
* 通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果。
*/
public class CallableAndFuture

/** *//**
* 自定义一个任务类,实现Callable接口
*/
public static class MyCallableClass implements Callable
// 标志位
private int flag = 0;
public MyCallableClass(int flag)
this.flag = flag;

public String call() throws Exception
if (this.flag == 0)
// 如果flag的值为0,则立即返回
return "flag = 0";

if (this.flag == 1)
// 如果flag的值为1,做一个无限循环
try
while (true)
System.out.println("looping.");
Thread.sleep(2000);

catch (InterruptedException e)
System.out.println("Interrupted");

return "false";
else
// falg不为0或者1,则抛出异常
throw new Exception("Bad flag value!");




public static void main(String[] args)
// 定义3个Callable类型的任务
MyCallableClass task1 = new MyCallableClass(0);
MyCallableClass task2 = new MyCallableClass(1);
MyCallableClass task3 = new MyCallableClass(2);

// 创建一个执行任务的服务
ExecutorService es = Executors.newFixedThreadPool(3);
try
// 提交并执行任务,任务启动时返回了一个 Future对象,
// 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作
Future future1 = es.submit(task1);
// 获得第一个任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行
System.out.println("task1: " + future1.get());

Future future2 = es.submit(task2);
// 等待5秒后,再停止第二个任务。因为第二个任务进行的是无限循环
Thread.sleep(5000);
System.out.println("task2 cancel: " + future2.cancel(true));

// 获取第三个任务的输出,因为执行第三个任务会引起异常
// 所以下面的语句将引起异常的抛出
Future future3 = es.submit(task3);
System.out.println("task3: " + future3.get());
catch (Exception e)
System.out.println(e.toString());

// 停止任务执行服务
es.shutdownNow();

ExecutorService——shutdown方法和awaitTermination方法

ExecutorService的关闭
shutdown和awaitTermination为接口ExecutorService定义的两个方法，一般情况配合使用来关闭线程池。

方法简介
shutdown方法：平滑的关闭ExecutorService，当此方法被调用时，ExecutorService停止接收新的任务并且等待已经提交的任务（包含提交正在执行和提交未执行）执行完成。当所有提交任务执行完毕，线程池即被关闭。

awaitTermination方法：接收人timeout和TimeUnit两个参数，用于设定超时时间及单位。当等待超过设定时间时，会监测ExecutorService是否已经关闭，若关闭则返回true，否则返回false。一般情况下会和shutdown方法组合使用。

具体实例
普通任务处理类：

package com.secbro.test.thread;

import java.util.concurrent.Callable;

/**
 * @author zhuzhisheng
 * @Description
 * @date on 2016/6/1.
 */
public class Task implements Callable{
    @Override
    public Object call() throws Exception {
        System.out.println("普通任务");
        return null;
    }
}

长时间任务处理类：

package com.secbro.test.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * @author zhuzhisheng
 * @Description
 * @date on 2016/6/1.
 */
public class LongTask implements Callable{
    @Override
    public Object call() throws Exception {
        System.out.println("长时间任务");
        TimeUnit.SECONDS.sleep(5);
        return null;
    }
}

测试类：

package com.secbro.test.thread;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @author zhuzhisheng
 * @Description
 * @date on 2016/6/1.
 */
public class TestShutDown {

    public static void main(String[] args) throws InterruptedException{
        ScheduledExecutorService service = Executors.newScheduledThreadPool(4);

        service.submit(new Task());
        service.submit(new Task());
        service.submit(new LongTask());
        service.submit(new Task());


        service.shutdown();

        while (!service.awaitTermination(1, TimeUnit.SECONDS)) {
            System.out.println("线程池没有关闭");
        }

        System.out.println("线程池已经关闭");
    }

}

输出结果为：

普通任务
普通任务
长时间任务
普通任务
线程池没有关闭
线程池没有关闭
线程池没有关闭
线程池没有关闭
线程池已经关闭