Executors 框架

Executors 框架，是一个根据一组执行策略调用、调度、执行和控制的异步任务的框架。

不使用线程池，创建线程数量不加控制或控制不当，会导致应用程序内存溢出。所以，创建线程池是一个很好的解决方案。它可以限制核心线程数量，还可以回收再利用使用结束的线程。利用Executors 框架可以非常方便的创建一个线程池。

Executors类源码如下：

package java.util.concurrent;

import java.lang.Thread.UncaughtExceptionHandler;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import sun.security.util.SecurityConstants;

public class Executors {
    public static ExecutorService newFixedThreadPool(int var0) {
        return new ThreadPoolExecutor(var0, var0, 0L, TimeUnit.MILLISECONDS, new linkedBlockingQueue());
    }

    public static ExecutorService newWorkStealingPool(int var0) {
        return new ForkJoinPool(var0, ForkJoinPool.defaultForkJoinWorkerThreadFactory, (UncaughtExceptionHandler)null, true);
    }

    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool(Runtime.getRuntime().availableProcessors(), ForkJoinPool.defaultForkJoinWorkerThreadFactory, (UncaughtExceptionHandler)null, true);
    }

    public static ExecutorService newFixedThreadPool(int var0, ThreadFactory var1) {
        return new ThreadPoolExecutor(var0, var0, 0L, TimeUnit.MILLISECONDS, new linkedBlockingQueue(), var1);
    }

    public static ExecutorService newSingleThreadExecutor() {
        return new Executors.FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new linkedBlockingQueue()));
    }

    public static ExecutorService newSingleThreadExecutor(ThreadFactory var0) {
        return new Executors.FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new linkedBlockingQueue(), var0));
    }

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue());
    }

    public static ExecutorService newCachedThreadPool(ThreadFactory var0) {
        return new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue(), var0);
    }

    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new Executors.DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));
    }

    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory var0) {
        return new Executors.DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1, var0));
    }

    public static ScheduledExecutorService newScheduledThreadPool(int var0) {
        return new ScheduledThreadPoolExecutor(var0);
    }

    public static ScheduledExecutorService newScheduledThreadPool(int var0, ThreadFactory var1) {
        return new ScheduledThreadPoolExecutor(var0, var1);
    }

    public static ExecutorService unconfigurableExecutorService(ExecutorService var0) {
        if (var0 == null) {
            throw new NullPointerException();
        } else {
            return new Executors.DelegatedExecutorService(var0);
        }
    }

    public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService var0) {
        if (var0 == null) {
            throw new NullPointerException();
        } else {
            return new Executors.DelegatedScheduledExecutorService(var0);
        }
    }

    public static ThreadFactory defaultThreadFactory() {
        return new Executors.DefaultThreadFactory();
    }

    public static ThreadFactory privilegedThreadFactory() {
        return new Executors.PrivilegedThreadFactory();
    }

    public static  Callable callable(Runnable var0, T var1) {
        if (var0 == null) {
            throw new NullPointerException();
        } else {
            return new Executors.RunnableAdapter(var0, var1);
        }
    }

    public static Callable