所有Java程序员有要懂的线程池：线程池是什么？为什么要用线程池？怎么用线程池？

    ThreadPoolExecutor
    ScheduledThreadPoolExecutor

    public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    ...
    }

    corePoolSize the number of threads to keep in the pool, even if they are idle, unless {@code allowCoreThreadTimeOut} is set

    maximumPoolSize the maximum number of threads to allow in the pool

    keepAliveTime when the number of threads is greater than the core,this is the maximum time that excess idle threads will wait for new tasks before terminating.

    unit the time unit for the {@code keepAliveTime} argument

    workQueue the queue to use for holding tasks before they are executed.

    threadFactory the factory to use when the executor creates a new
    thread

    handler the handler to use when execution is blocked because the thread bounds and queue capacities are reached

    newCachedThreadPool
    newFixedThreadPool
    newSingleThreadExecutor

    newCachedThreadPool
    public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
    }

    These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks.

    public class newCacheThreadPool {
    
    public static void main(String[] args) {
        // 创建一个线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        // 向线程池提交任务
        for (int i = 0; i < 50; i++) {
            executorService.execute(new Task());//线程池执行任务
        }
        executorService.shutdown();
    }
    }

    newFixedThreadPool
    public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
    }

    Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.
    
    public class FixedThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 200; i++) {
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
    }

    newSingleThreadExecutor
    public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
    }

    Creates an Executor that uses a single worker thread operating off an unbounded queue.

    public class SingleThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
    }

    defaultHandler。
    /** * The default rejected execution handler
     */
    private static final RejectedExecutionHandler defaultHandler =
    new AbortPolicy();