Java源码阅读之Executors

Summary：

• 该类可以生成四种类型的线程池：
  • 不限定数量的线程池
  • 限定数量的线程池
  • 只有一个线程的线程"池"
  • 为预定执行而构建的线程池
  • 前三者是用ThreadPoolExecutor来构建线程池的；返回的对象是一个ExecutorService；因为ThreadPoolExecutor继承了 AbstractExecutorService类，也就间接的实现了ExecutorService接口；
  • 后者特殊单独讲
• 该类定义了内部适配器类，用于将Runnable转换为Callable类型，即变成带返回值的运行方法，当然这个返回值默认值是null；在FuctureTash构造器会用到
• 该类定义了一个线程工厂；从该工厂创建出来的线程都是非守护线程，优先级normal，的普通线程；在ThreadPoolExecutor构造器中被使用；

newCachedThreadPool：

//必要时创建新线程；空闲线程保留60秒
//这里的SynchronousQueue是一个同步队列，即size永远为0，存的数只有被取走才能再存一个；
//即如果当前没有空线程则创建一个新线程；空线程保留60s后自动销毁
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());  
}

newFixedThreadPool：

//包含固定数量的线程，空线程一直保留
//创建nThreads个线程，请求如果没有空线程可以自行则存入LinkedBlockingQueue，该队列可以存入的线程是无界的；(可能会耗尽系统资源！！！任务疯涨的情况)
public static ExecutorService newFixedThreadPool(int nThreads){
    return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

newSingleThreadExecutor：

//只有一个线程的线程池
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}

newScheduledThreadPool

//预定执行而构建的固定线程池
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
}

内部类

DefaultThreadFactory 
//ThreadPoolExecutor会用到
static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" + poolNumber.getAndIncrement() +"-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false); //非守护线程
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
}

RunnableAdapter

//FuctureTask构造器会用到
//将Runnable转化为Callable<T>对象
public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
}
//RunnableAdapter是内部类，适配器模式
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();
            return result;
        }
}