高并发：线程池执行流程，拒绝策略，JDK内置线程池

线程是珍贵的资源，每创建一个线程jvm都要给予分配栈空间和堆空间，创建的过程是一个比较消耗性能的过程。而且过多的线程可能会引起栈溢出或内存溢出等异常，甚至是文件句柄不够（linux默认非root用户文件句柄为1024）。

基于以上考虑，对线程进行有效的管控是一个提高性能必要的选择，特别是高并发环境下。jdk为我们提供了线程池来管理线程。

1. 线程池原理

image.png

2. 饱和策略

1. AbortPolicy:默认的策略，直接抛出RejectedExecutionException异常
2. CallerRunsPolicy：这个策略比较有意思，看源码可以直接内部直接调用了run方法，这相当于直接让调用execute方法的线程直接执行这个方法了。

    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() { }

        /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

3. DiscardOldestPolicy：将等待队列中的第一个任务抛弃，并重试execute方法，这个方式在高并发环境，并且大部分任务的执行时间都比较长的情况下，可能会造成现场饥饿死锁

   public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
        public DiscardOldestPolicy() { }

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

4. DiscardPolicy：就是什么都不干，抛弃当前任务

    public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardPolicy}.
         */
        public DiscardPolicy() { }

        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

3.jdk内置的几种线程池

1. CachedThreadPool：
   没有线程上线的线程池，线程空闲60s就回收，使用该线程要比较小心，假设创建的线程过多会使系统崩溃，不建议在高并发情况下使用。

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

2. FixedThreadPool：
   固定大小的线程池，使用该线程池的时候，一定要注意分配的线程数数量，避免资源的浪费或者资源的不足情况。

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

3. SingleThreadExecutor：
   只有单个线程,该线程池能保证任务按FIFO的顺序执行。

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

4. newScheduledThreadPool：
   创建一个定时任务线程池

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

ps：在jdk1.8下的源码