ExecutorService的理解与简单使用

ExecutorService的简介

接口 java.util.concurrent.ExecutorService 表述了异步执行的机制，并且可以让任务在后台执行。一个ExecutorService 实例因此特别像一个线程池。事实上，在 java.util.concurrent 包中的ExecutorService的实现就是一个线程池的实现

ExecutorService的实现

由于 ExecutorService 只是一个接口，你如果需要使用它，那麽就需要提供一个该接口的实现。ExecutorService 接口在 java.util.concurrent 包中有如下实现类：

这里我简单使用其中2个实现类

1. ThreadPoolExecutor

2. ScheduledThreadPoolExecutor

ExecutorService样例

这里有一个简单的使用Java 实现的 ExectorService 样例:

首先使用 newFixedThreadPool() 工厂方法创建一个 ExecutorService ，创建了一个可以容纳10个线程任务的线程池。其次，向 execute() 方法中传递一个异步的 Runnable 接口的实现，这样做会让 ExecutorService 中的某个线程执行这个Runnable 线程

    @Test
    public void executeRunnable() {
//       创建固定线程数量的线程池
        executorService2 = Executors.newFixedThreadPool(10);
//        异步执行线程任务
        executorService2.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("Asynchronous task");
            }
        });
//        等待所有的线程执行线程任务完毕后,关闭线程
        executorService2.shutdown();
    }

任务的委托(Task Delegation)

下方展示了一个线程的把任务委托异步执行的ExecutorService的示意图。

一旦线程把任务委托给 ExecutorService，该线程就会继续执行与运行任务无关的其它任务。

创建一个ExecutorService

你可以根据自己的需要来创建一个 ExecutorService ，也可以使用 Executors 工厂方法来创建一个 ExecutorService 实例。这里有几个创建 ExecutorService 的例子:

    private ExecutorService executorService1;
    private ExecutorService executorService2;
    private ScheduledExecutorService executorService3;

    private static Logger log = Logger.getLogger(ExecutorDemo.class);

    @BeforeEach
    private void studyExecutor() {
//        创建线程池的三种方式
//        1.创建SingleThread,创建一个线程的线程池
        executorService1 = Executors.newSingleThreadExecutor();

//        2.创建固定线程数量的线程池
        executorService2 = Executors.newFixedThreadPool(10);

//        3.创建周期性线程池
        executorService3 = Executors.newScheduledThreadPool(10);
    }

ExecutorService使用方法

这里有几种不同的方式让你将任务委托给一个 ExecutorService：

execute(new Runnable() {})
submit(new Runnable() {})
submit(new Callable<Object>() {})
invokeAny(...)
invokeAll(...)

接下来把每個方法都试试看

execute(Runnable)

方法 execute(Runnable) 接收一个 java.lang.Runnable 对象作为参数，并且以异步的方式执行它。如下是一个使用 ExecutorService 执行 Runnable 的例子：

@Test
    public void executeRunnable() {
//       创建固定线程数量的线程池
        executorService2 = Executors.newFixedThreadPool(10);
//        异步执行线程任务
        executorService2.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("Asynchronous task");
            }
        });
//        等待所有的线程执行线程任务完毕后,关闭线程
        executorService2.shutdown();
    }

使用这种方式没有办法获取执行 Runnable 之后的结果，如果你希望获取运行之后的返回值，就必须使用接收 Callable 参数的 execute() 方法，后者将会在下文中提到。

submit(Runnable)

方法 submit(Runnable) 同样接收一个 Runnable 的实现作为参数，但是会返回一个 Future 对象。这個 Future 对象可以用于判断 Runnable 是否结束执行。如下是一个 ExecutorService 的 submit() 方法的例子：

    @Test
    public void submitRunnable() {
        Future<?> future = executorService2.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("Asynchronous task");
            }
        });
        try {
//            如果任务执行结束则返回null
            System.out.println("future.get()>>>>>>" + future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        executorService2.shutdown();
    }

submit(Callable)

方法 submit(Callable) 和方法 submit(Runnable) 比较类似，但是区别则在于它们接收不同的参数类型。Callable 的实例与 Runnable 的实例很类似，但是 Callable 的 call() 方法可以返回一个结果。方法 Runnable.run() 则不能返回结果。

Callable 的返回值可以从方法 submit(Callable) 返回的 Future 对象中获取。如下是一个 ExecutorService Callable 的样例：

    @Test
    public void submitCallableRunnable() {
        Future<Object> future = executorService2.submit(new Callable<Object>() {
//            使用Callable接口可以返回一个结果
            @Override
            public Object call() throws Exception {
                return "Callable Result";
            }
        });
        try {
//            获取Callable接口中call()方法的返回结果
            System.out.println("future.get()>>>>>>>>  " + future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executorService2.shutdown();
    }

上述样例代码会输出如下结果：

future.get()>>>>>>>>  Callable Result
Process finished with exit code 0

inVokeAny()

方法 invokeAny() 接收一个包含 Callable 对象的集合作为参数。调用该方法不会返回 Future 对象，而是返回集合中某一个 Callable 对象的结果，而且无法保证调用之后返回的结果是哪一个 Callable，只知道它是这些 Callable 中一个执行结束的 Callable 对象。
如果一个任务运行完毕或者抛出异常，方法会取消其它的 Callable 的执行。
以下是一个样例：

@Test
public void inVokeAnyRunnable() {
  
    List<Callable<String>> callableList = new ArrayList<Callable<String>>();
    callableList.add(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "Task1";
        }
    });

    callableList.add(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "Task2";
        }
    });

    callableList.add(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "Task3";
        }
    });

    try {
        String result = executorService2.invokeAny(callableList);
        log.info("result>>>>>>>>>>>>>>  " + result);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
  
    executorService2.shutdown();
}

以上样例代码会打印出在给定的集合中的某一个 Callable 的返回结果。我尝试运行了几次，结果都在改变。有时候返回结果是”Task 1”，有时候是”Task 2”，等等。

invokeAll()

方法 invokeAll() 会调用存在于参数集合中的所有 Callable 对象，并且返回一个包含 Future 对象的集合，你可以通过这个返回的集合来管理每个 Callable 的执行结果。
需要注意的是，任务有可能因为异常而导致运行结束，所以它可能并不是真的成功运行了。但是我们没有办法通过 Future 对象来了解到这个差异。
以下是一个代码样例：

@Test
public void inVokeAllRunnable() {

    List<Callable<String>> callableList = new ArrayList<Callable<String>>();
    callableList.add(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "Task1";
        }
    });

    callableList.add(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "Task2";
        }
    });

    callableList.add(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "Task3";
        }
    });
    try {
        List<Future<String>> futureList = executorService2.invokeAll(callableList);
        for (Future<String> future : futureList) {
            log.info("future.get()>>>>>>>  " + future.get());
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }

    executorService2.shutdown();
}

ExecuteService服务的关闭

当使用 ExecutorService 完毕之后，我们应该关闭它，这样才能保证线程不会继续保持运行状态。
举例来说，如果你的程序通过 main() 方法启动，并且主线程退出了你的程序，如果你还有一个活动的 ExecutorService 存在于你的程序中，那么程序将会继续保持运行状态。存在于 ExecutorService 中的活动线程会阻止Java虚拟机关闭。
为了关闭在 ExecutorService 中的线程，你需要调用 shutdown() 方法。ExecutorService 并不会马上关闭，而是不再接收新的任务，一旦所有的线程结束执行当前任务，ExecutorServie 才会真的关闭。所有在调用 shutdown() 方法之前提交到 ExecutorService 的任务都会执行。
如果你希望立即关闭 ExecutorService，你可以调用 shutdownNow() 方法。这个方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证的，有可能他们真的被关闭掉了，也有可能它会一直执行到任务结束。这是一个最好的尝试。

分享

• 新浪微博




• QQ空间




• QQ好友




• 豆瓣




• Facebook




• Twitter

取消