第十四章 Executors源码解析

package com.collection.test;

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

public class ThreadPoolExecutorTest {
    //private static ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
    //private static Executor executor = Executors.newFixedThreadPool(5);
    //private static Executor executor = Executors.newSingleThreadExecutor();
    //private static Executor executor = Executors.newCachedThreadPool();
    private static Executor executor = Executors.newScheduledThreadPool(5);
    
    public void executeTask(){
        Task1 task1 = new Task1();//构建任务1
        Task2 task2 = new Task2();//构建任务2
        executor.execute(task1);//执行任务1
        executor.execute(task2);//执行任务2
    }
    
    /*
     * 基本任务2
     */
    class Task1 implements Runnable{
        public void run() {
            //具体任务的业务
            for(int i=0;i<1000;i++){
                System.out.println("hello xxx!!!");
            }
        }
    }
    
    /*
     * 基本任务2
     */
    class Task2 implements Runnable{
        public void run() {
            //具体任务的业务
            for(int i=0;i<5;i++){
                System.out.println("hello world2!!!");
            }
        }
    }
    
    public static void main(String[] args) {
        ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
        test.executeTask();
    }
}

    /**
     * 1、创建一个线程数固定（corePoolSize==maximumPoolSize）的线程池,
     * 2、核心线程会一直运行
     * 3、无界队列LinkedBlockingQueue
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    /**
     * 1、创建一个线程数固定（corePoolSize==maximumPoolSize==1）的线程池
     * 2、核心线程会一直运行
     * 3、无界队列LinkedBlockingQueue
     * 注意：所有task都是串行执行的
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    /**
     * 1、创建一个线程池：当池中的线程都处于忙碌状态时，会立即新建一个线程来处理新来的任务
     * 2、这种池将会在执行许多耗时短的异步任务的时候提高程序的性能。
     * 3、6秒钟内没有使用的线程将会被中止，并且从线程池中移除，因此几乎不必担心耗费资源
     * 4、队列：SynchronousQueue
     * 5、maximumPoolSize为Integer.MAX_VALUE
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

    /**
     * 创建一个线程池：该线程池可以用于执行延时任务或者定时任务
     */
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

    /**
     * 创建一个线程池：
     * corePoolSize==我们指定
     * maximumPoolSize==Integer.MAX_VALUE
     * keepAliveTime==0纳秒（即不回收闲置线程）
     * 队列： DelayedWorkQueue
     */
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayedWorkQueue());
    }

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        schedule(command, 0, TimeUnit.NANOSECONDS);
    }

    /**
     * 这个方法：其实就是将task封装一下，然后加入到DelayedWorkQueue中
     * 1、DelayedWorkQueue其实就是一个DelayQueue
     * 2、当有新的task加入时，DelayQueue会将其加入内部的数组对象中，并对其进行排序，在这里，排序的规则就是执行的时间，执行时间越近的排在越前
     * 3、线程池中的线程在执行task时，获取最近要执行的task，然后唤醒所有等待available条件的线程来执行该任务
     */
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        RunnableScheduledFuture<?> t = decorateTask(command,
                                                    new ScheduledFutureTask<Void>(command, null, triggerTime(delay, unit)));

        delayedExecute(t);
        return t;
    }

    /**
     * 返回一个delayed action（延时任务）的触发时间
     */
    private long triggerTime(long delay, TimeUnit unit) {
         return triggerTime(unit.toNanos((delay < 0) ? 0 : delay));
    }

    /**
     * Returns the trigger time of a delayed action.
     */
    long triggerTime(long delay) {
         return now() +
             ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
    }

    private class ScheduledFutureTask<V>
            extends FutureTask<V> implements RunnableScheduledFuture<V> {

        private final long sequenceNumber;//用于打破FIFO关系的序列号
        private long time;//任务执行的触发时间
        /**
         * 一个用于重复执行的任务的时间段（单位：纳秒）
         * 0-->不重复执行的任务
         * 正值：fixed-rate执行
         * 负值：fixed-delay执行
         */
        private final long period;

        /**
         * 创建一个一次性的action并且指定触发时间
         */
        ScheduledFutureTask(Runnable r, V result, long ns) {
            super(r, result);
            this.time = ns;
            this.period = 0;
            this.sequenceNumber = sequencer.getAndIncrement();
        }

    private final Sync sync;//控制FutureTask的同步器

    public FutureTask(Runnable runnable, V result) {
        sync = new Sync(Executors.callable(runnable, result));
    }

    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

    static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable  task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();//这里是真正的task运行的地方
            return result;
        }
    }

    protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, 
                                                          RunnableScheduledFuture<V> task) {
        return task;
    }

    private void delayedExecute(Runnable command) {
        if (isShutdown()) {//return runState != RUNNING;线程池状态不是RUNNING
            reject(command);//回绝任务
            return;
        }
        
        if (getPoolSize() < getCorePoolSize())//当前线程池数量少于核心线程数
            prestartCoreThread();//创建并启动一个核心线程

        super.getQueue().add(command);//获取阻塞队列，并将command加入队列
    }

    public boolean add(E e) {
        return offer(e);
    }

    public boolean offer(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            E first = q.peek();//获取队列头部节点但不删除
            q.offer(e);//将e放到q的尾部
            //如果队列中只有e或者e的触发时间小于队头结点
            if (first == null || e.compareTo(first) < 0)
                available.signalAll();
            return true;
        } finally {
            lock.unlock();
        }
    }