Executor框架和线程池简单介绍

Executor框架

 

Executor

是一个接口，仅要求实现void execute(Runnable command);，要求是在各种场合（新开的线程、线程池内等等），同步（在execute方法里立刻执行）或异步得完成某一任务。

自己定义类实现Executor接口：

public class T_MyExecutor implements Executor {

    @Override

    public void execute(Runnable command) {

         command.run();

    }

    public static void main(String[] args) {

        new T_MyExecutor().execute(()->{

 

            System.out.println("hello executor");

        });

}

}

ExecutorService

接口，继承自Executor，扩展了Executor并添加了一些生命周期管理的方法。

一个ExecutorService的生命周期有三种状态：运行、关闭、中止。

当调用ExecutorService.shutdown()后，处于关闭状态，isShutdown()方法返回true。此时无法新加任务。

所有已添加的任务关闭后，Executor处于终止状态，isTerminated()返回true。这要求之前肯定调用过shutdown或shutdownNow。可以用awaitTermination阻塞式得等待所有任务都已经关闭。

此外，调用多了submit和invoke：

submit和executor的区别在于它的入参可以是Runnable也可以是Callable，而且有返回值Future<?>

invoke系（invokeAll、invokeAny）的入参都有Collection<? extends Callable<T>> tasks，返回T或T的集合。

Future FutureTask

Future<V>是一个接口，规定了异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则get()会使当前线程阻塞，可以指定等待时间。cancel方法取消操作。

FutureTask<V>是一个类，实现了RunnableFuture<V>，该接口继承自Runnable和Future<V>
内部持有一个Callable<V>，构造函数需要一个Callable<V>但也可以接受一个Runnable
（转化this.callable = Executors.callable(runnable, result);）
异步的原理：

• 持有一个volatile int state，表面目前的状态，是新建还是完成还是取消之类的。
• 内部类WaitNode，是一个存储thread的链表，当前节点指向当前线程，next指向下一个可用线程。通过CAS操作更改运行线程。
• 通过LockSupport.park在运行完成前阻塞获取，LockSupport.unpark取消阻塞。

CompletableFuture

·  提供了异步程序执行的另一种方式：回调，不需要像future.get()通过阻塞线程来获取异步结果或者通过isDone来检测异步线程是否完成来执行后续程序。

·  能够管理多个异步流程，并根据需要选择已经结束的异步流程返回结果。

多个CompletableFuture任务的管理

现实应用中可能同时存在多个异步任务，有时候我们需要他们一起完成才能进行下面的操作，有时候我们又只需要在存在一个结果的情况下就返回。

如下案例：

 

假设你能够提供一个服务

这个服务查询各大电商网站同一类产品的价格并汇总展示

 

public class T_CompletableFuture {

 

    public static void main(String[] args) {

        long start, end;

 

        start = System.currentTimeMillis();

 

        CompletableFuture<Double> futureTM = CompletableFuture.supplyAsync(() ->

                priceOfJD());

 

        CompletableFuture<Double> futureTB = CompletableFuture.supplyAsync(() ->

                priceOfTB());

 

        CompletableFuture<Double> futureJD = CompletableFuture.supplyAsync(() ->

                priceOfTM());

 

        CompletableFuture.allOf(futureTM, futureTB, futureJD).join();

 

        end = System.currentTimeMillis();

 

        System.out.println("use completable future! " + (end - start));

 

        try {

            System.in.read();

        } catch (IOException e) {

            e.printStackTrace();

        }

 

    }

 

    private static double priceOfTM() {

        delay();

        return 1.00;

    }

 

    private static double priceOfTB() {

        delay();

        return 2.00;

    }

 

    private static double priceOfJD() {

        delay();

        return 3.00;

    }

 

 

    private static void delay() {

        int time = new Random().nextInt(500);

        try {

            TimeUnit.MILLISECONDS.sleep(time);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.printf("After %s sleep!\n", time);

    }

}

 

 

 

ThreadPoolExecutor

ThreadPoolExecutor 继承自AbstractExecutorService，后者实现了ExecutorService
首先实现了ExecutorService的各方法
构造函数和各参数：

 

·  corePoolSize：核心线程数

·  maximumPoolSize：最大线程数

·  keepAliveTime：线程空闲时间

·  TimeUnit 时间尺度

·  workQueue 阻塞队列，用于存放等待着的线程

·  threadFactory 线程工厂，给内部类worker提供线程

·  rejectedExecutionHandler：任务拒绝处理器
提供了四种方式来处理任务拒绝策略

1. 直接丢弃（DiscardPolicy）
2. 丢弃队列中最老的任务(DiscardOldestPolicy)。
3. 抛异常(AbortPolicy)
4. 将任务分给调用线程来执行(CallerRunsPolicy)。

举个例子：

public class T_HelloThreadPool {

 

    static class Task implements Runnable {

 

        private int i;

 

        public Task(int i) {

            this.i = i;

        }

 

        @Override

        public void run() {

            System.out.println(Thread.currentThread().getName() + "Task" + i);

            try {

                System.in.read();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

 

        @Override

        public String toString() {

            return "Task{" + "i=" + i + "}";

        }

    }

 

    public static void main(String[] args) {

        ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS,

                new ArrayBlockingQueue<>(4),

                Executors.defaultThreadFactory(),

                new ThreadPoolExecutor.CallerRunsPolicy());

 

        for (int i = 0; i < 8; i++) {

            tpe.execute(new Task(i));

        }

 

        System.out.println(tpe.getQueue());

 

        tpe.execute(new Task(100));

 

        System.out.println(tpe.getQueue());

 

        tpe.shutdown();

 

    }

}

结果：

 

 

核心线程是2个，最大线程是4个，任务队列的容量是4，最大可以放8个任务，

当添加第九个任务的时候，由于选择了CallerRunsPolicy拒绝策略，第九个任务由main线程调用了

 

内部有一个worker类作为任务执行者，HashSet<Worker> workers作为线程池，workQueue作为等待的队列

状态通过final AtomicInteger ctl保存
五个状态：

• RUNNING 接受新任务和处理队列里的任务
• SHUTDOWN 不接受新任务但是处理队列里的任务
• STOP 不接受新任务，不处理队列里的任务，中断处理中的任务
• TIDYING 所有任务都被关闭（terminated），workerCount为0，将调用terminated 
• TERMINATED terminated已被调用

状态转换：

• RUNNING -> SHUTDOWN 调用shutdown()，可能隐式地在finalize()时调用
• (RUNNING or SHUTDOWN) -> STOP 调用shutdownNow()时
• SHUTDOWN -> TIDYING 当队列和池都空的时候
• STOP -> TIDYING 当池空的时候
• TIDYING -> TERMINATED 当terminated()调用结束时

execute策略：
Proceed in 3 steps:

• 少于corePoolSize的线程在运行时，尝试新建一个线程处理这个任务。addWorker方法检查运行状态和workerCount。
• 如果一个线程可以被移出队列，检查状态判断是否要新加一个线程还是取消这个任务
• 如果不能从队列里拿出一个线程，就新加一个线程。失败了就取消这个任务。

线程池的工作过程如下（转个别人的总结）：

1. 线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
2. 当调用 execute() 方法添加一个任务时，线程池会做如下判断：
   1. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
   2. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。
   3. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；
   4. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。
3. 当一个线程完成任务时，它会从队列中取下一个任务来执行。
4. 当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

Executors

工具类

创建线程池，本质是生成ThreadPoolExecutor，举例：

newFixedThreadPool

 

public static ExecutorService newSingleThreadExecutor() {

    return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));

}

 

newFixedThreadPool

 

public static ExecutorService newFixedThreadPool(int nThreads) {

    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

}

 

newCachedThreadPool

 

public static ExecutorService newCachedThreadPool() {

    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());

}

• newCachedThreadPool 核心线程数为0
  可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池为Integer.MAX_VALUE大小，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
• newFixedThreadPool
  定长线程池，核心线程数和最大线程数都是一样大，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置，如Runtime.getRuntime().availableProcessors()。
• newSingleThreadExecutor
  创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
• newScheduledThreadPool
  创建一个定长线程池，支持定时及周期性任务执行。
• public class T_ScheduledPool {
•  
•     public static void main(String[] args) {
•         ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
•  
•         service.scheduleAtFixedRate(()->{
•  
•             try {
•                 TimeUnit.MILLISECONDS.sleep(new Random().nextInt());
•             } catch (InterruptedException e) {
•                 e.printStackTrace();
•             }
•  
•             System.out.println(Thread.currentThread().getName());
•  
•         },0,500, TimeUnit.MILLISECONDS);
•     }
• }
• ScheduledExecutorService 继承了ExecutorService

 

 

• public class T_ScheduledPool {
•  
•     public static void main(String[] args) {
•         ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
•  
•         service.scheduleAtFixedRate(()->{
•  
•             try {
•                 TimeUnit.MILLISECONDS.sleep(new Random().nextInt());
•             } catch (InterruptedException e) {
•                 e.printStackTrace();
•             }
•  
•             System.out.println(Thread.currentThread().getName());
•  
•         },0,500, TimeUnit.MILLISECONDS);
•     }
• }
• ScheduledExecutorService 继承了ExecutorService