Executor框架学习笔记

关于ThreadPoolExecutor的源码解读，请参考我的最新博客《ThreadPoolExecutor源码解读》。

Java中的线程即是工作单元也是执行机制，从JDK 5后，工作单元与执行机制被分离。工作单元包括Runnable和Callable，执行机制由JDK 5中增加的java.util.concurrent包中Executor框架提供。

HotSpot VM的线程模型中将java的线程映射为本地操作系统的线程，java线程的启动意味着一个本地操作系统线程的创建，而java线程的终止也就意味着对应的系统线程的回收。

Executor框架主要包含三个部分：

任务：包括Runnable和Callable，其中Runnable表示一个可以异步执行的任务，而Callable表示一个会产生结果的任务

任务的执行：包括Executor框架的核心接口Executor以及其子接口ExecutorService。在Executor框架中有两个关键类ThreadPoolExecutor和ScheduledThreadPoolExecutor实现了ExecutorService接口。

异步计算的结果：包括接口Future和其实现类FutureTask。

下面是对Executor框架中的一些关键接口与类的简介

Executor接口(java.util.concurrent.Executor)

它是Executor的基础与核心，其定义如下：

public interface Executor {
    void execute(Runnable command);
}

它包含了一个方法execute，参数为一个Runnable接口引用。

Executor接口将任务的提交与执行分离开来。

ThreadPoolExecutor类(java.util.concurrent.ThreadPoolExecutor)

它是线程池的核心实现类，用来执行被提交的任务。

它通常由工厂类Executors来创建，Executors可以创建SingleThreadExecutor，FixedThreadPool以及CachedThreadPool等不同的ThreadPoolExecutor。

SingleThreadExecutor使用单线程执行任务，Executors提供的API有如下两个

public static ExecutorService newSingleThreadExecutor();
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory);

SingleThreadExecutor保证了任务执行的顺序，不会存在多线程活动。

FixedThreadPool是使用固定线程数的线程池,Executors提供的API有如下两个

 public static ExecutorService newFixedThreadPool(int nThreads);
 public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

FixedThreadPool满足了资源管理的需求，可以限制当前线程数量。适用于负载较重的服务器环境。

CachedThreadPool是无界线程池，Executors提供的API有如下两个

public static ExecutorService newCachedThreadPool();
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory);

CachedThreadPool适用于执行很多短期异步任务的小程序，适用于负载较轻的服务器。

ScheduledThreadPoolExecutor类(java.util.concurrent.ScheduledThreadPoolExecutor)

它是ThreadPoolExecutor的子类且实现了ScheduledExecutorService接口，它可以在给定的延迟时间后执行命令，或者定期执行命令，它比Timer更强大更灵活。

Executors可以创建的ScheduledThreadPoolExecutor的类型有ScheduledThreadPoolExecutor和SingleThreadScheduledExecutor等

ScheduledThreadPoolExecutor具有固定线程个数，适用于需要多个后台线程执行周期任务，并且为了满足资源管理需求而限制后台线程数量的场景,Executors中提供的API有如下两个：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize);
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory);

SingleThreadScheduledExecutor具有单个线程，Executors提供的创建API有如下两个：

public static ScheduledExecutorService newSingleThreadScheduledExecutor();
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory);

它适用于单个后台线程执行周期任务，并且保证顺序一致执行的场景。

上述的ThreadPoolExecutor和ScheduledThreadPoolExecutor都可以用于执行Runnable与Callable接口的实现类

Future接口(Java.concurrent.Future)

Future代表着提交的任务的计算状态与结果，可以对其进行取消，查询是否取消，查询是否完成，查询结果等操作。

首先来看一下Future接口的定义：

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

}

FutureTask类间接实现了Future接口，它用来表示异步计算的结果。当ThreadPoolExecutor或者ScheduledThreadPoolExecutor执行Runnable接口或者Callable接口的实现类时，它们会返回一个Future接口引用（实现类为FutureTask）。

Runnable接口或者Callable接口的实现类在被上述两者执行的区别是，前者没有返回结果，而后者可以返回结果。Runnable可以通过Executors提供的API(Executors#callable)包装为Callable。

本文参考资料：《Java并发编程的艺术》以及其他网上文档

-----------------------------------------------------------------------------------------------------------------

下面是一些简单的Demo程序

 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;

 public class ExecutorTest {
     public static void main(String[] args) {

         Runnable hello = () -> {
             for (int i = 0; i < 100; i++) {
                 System.out.println(i + " hello");
             }
         };
         Runnable bye = () -> {
             for (int i = 0; i < 100; i++) {
                 System.out.println(i + " bye");
             }
         };

         Executor executor = Executors.newCachedThreadPool();

         executor.execute(hello);
         executor.execute(bye);

     }
 }

上面程序使用了两个Runnable任务hello和bye来打印相应语句，程序将会交错打印hello和bye。如果将executor改为SingleThreadExecutor，将会先打印100个"hello"，再打印100个"bye"。

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 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;

 public class ExecutorTest {
     public static void main(String[] args) {
         Random random = new Random();
         List<Integer> numbers = new ArrayList<>();
         for (int i = 0; i < 100000; i++) {
             numbers.add(random.nextInt(100000));
         }
         int result = calculate(numbers, 3);
         System.out.println(result);
     }

     public static int calculate(List<Integer> numbers,int digit) {
         List<Callable<Integer>> tasks = new ArrayList<>();
         for (Integer x : numbers) {
             tasks.add(() -> {
                 int count=0;
                 int y=x;
                 do {
                     if (y % 10 == digit) {
                         count++;
                     }
                     y /= 10;
                 } while (y > 0);
                 return count;
             });
         }
         ExecutorService service = Executors.newFixedThreadPool(10);
         int answer=0;
         try {
             List<Future<Integer>> results = service.invokeAll(tasks);
             for (Future<Integer> result : results) {
                 try {
                     answer+=result.get();
                 } catch (ExecutionException e) {
                     e.printStackTrace();
                 }
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         return answer;
     }
 }

上面的程序随机生成了100000个随机数，然后统计这些数字中每个数字10进制中具有多少个数位3的数量和。使用具有10个线程的线程池进行计算，最终通过Future引用对象的结果来统计答案。