Java并发之ExecutorService

一、ExecutorService 介绍

​ ExecutorService 是 java.util.concurrent 包的重要组成部分，是 Java JDK 提供的框架，用于简化异步模式下任务的执行。

二、实例化ExecutorService 类

(1) 工厂方法

ExecutorService executor = Executors.newFixedThreadPool(50);

(2) 直接创建 ExecutorService 的实例

ExecutorService executorService = 
  new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,   
  new LinkedBlockingQueue<Runnable>()
);

三、将任务分配给ExecutorService

Runnable runnableTask = () -> {
    try {
        TimeUnit.MILLISECONDS.sleep(300);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
};

Callable<String> callableTask = () -> {
    TimeUnit.MILLISECONDS.sleep(300);
    return "callableTask's execution";
};

List<Callable<String>> callableTasks = new ArrayList<>();
callableTasks.add(callableTask);
callableTasks.add(callableTask);
callableTasks.add(callableTask);

// 调用方法一 该方法返回值为空 ( void )。因此使用该方法没有任何可能获得任务执行结果或检查任务的状态（ 是正在运行 ( running ) 还是执行完毕 ( executed ) ）。
executorService.execute(runnableTask);

// 调用方法二  submit() 方法会将一个 Callable 或 Runnable 任务提交给 ExecutorService 并返回 Future 类型的结果。
Future<String> future = executorService.submit(callableTask);

// 调用方法三  invokeAny() 方法将一组任务分配给 ExecutorService，使每个任务执行，并返回任意一个成功执行的任务的结果 ( 如果成功执行 )
String result = executorService.invokeAny(callableTasks);

// 调用方法四  invokeAll() 方法将一组任务分配给 ExecutorService ，使每个任务执行，并以 Future 类型的对象列表的形式返回所有任务执行的结果。
List<Future<String>> futures = executorService.invokeAll(callableTasks);

四、关闭ExecutorService

（1） shutdown() 方法

// shutdown() 方法并不会立即销毁 ExecutorService 实例，而是首先让 ExecutorService 停止接受新任务，并在所有正在运行的线程完成当前工作后关闭。
executorService.shutdown();

(2) shutdownNow() 方法

// shutdownNow() 方法会尝试立即销毁 ExecutorService 实例，所以并不能保证所有正在运行的线程将同时停止。该方法会返回等待处理的任务列表，由开发人员自行决定如何处理这些任务。
List<Runnable> notExecutedTasks = executorService.shutDownNow();

(3) awaitTermination() 方法

// 关闭 ExecutorService 实例的最佳方案（ 也是 Oracle 所推荐的 ）就是同时使用这两种方法并结合 awaitTermination() 方法。使用这种方式，ExecutorService 首先停止执行新任务，等待指定的时间段完成所有任务。如果该时间到期，则立即停止执行
executorService.shutdown();
try {
    if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) {
        executorService.shutdownNow();
    } 
} catch (InterruptedException e) {
    executorService.shutdownNow();
}

五、完整实现类

package day01;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 *  ExcutorService 功能测试类
 *  
 */
public class ExcutorServiceTest {
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		 
		// 工场方法  
		ExecutorService executor = Executors.newFixedThreadPool(10);
		
		// 直接创建实例
		ExecutorService executorService =  
				new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
		 
		Runnable runnableTask = () -> {
		    //TimeUnit.MILLISECONDS.sleep(300);
			System.out.println("runnableTask's execution");
		};

		Callable<String> callableTask = () -> {
		   // TimeUnit.MILLISECONDS.sleep(300);
		    System.out.println("callableTask's execution");
		    return "成功!";
		};

		List<Callable<String>> callableTasks = new ArrayList<>();
		callableTasks.add(callableTask);
		callableTasks.add(callableTask);
		callableTasks.add(callableTask);

		// 调用方法一
		executorService.execute(runnableTask);

		// 调用方法二
		Future<String> future = executorService.submit(callableTask);

		// 调用方法三
		String result = executorService.invokeAny(callableTasks);

		// 调用方法四
		List<Future<String>> futures = executorService.invokeAll(callableTasks);
		
		
	    // 关闭executorService 实例
		executorService.shutdown();
		try {
		    if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) {
		        executorService.shutdownNow();
		    } 
		} catch (InterruptedException e) {
		    executorService.shutdownNow();
		}
	
	}

}