JUC之线程池-三大方法-七大参数-四种拒绝策略

线程池：重点 三大方法 七大参数 四种拒绝策略

    使用池化技术的理由：
                    我们的程序伴随着创建销毁线程十分浪费资源，
                    所以使用线程池，先创建线程，随用随取，用完归还
                    简单来说就是节约了资源。

    使用线程池的好处：节省资源（最大并发线程数可控）；提高了响应速度；方便管理

三大方法：
    1.newFixedThreadPool(线程数):创建指定数量线程的线程池
    2.newSingleThreadExecutor():创建单线程的线程池
    3.newCacheThreadPool():随着请求的增多线程也随之创建，遇强则强

    我们之前都是用Executors创建线程池的，但是到了后期强制不可以用
    因此现在用ThreadPoolExecutor创建线程池
    为什么不能使用Executors创建线程池呢？
        1.FixedThreadPool和SingleThreadPool允许的请求队列的长度很大，约为21亿，
            所以可能堆积大量的请求，导致oom
        2.CachedThreadPool允许创建的线程数量很大，可能会导致创建大量的线程，从而导致oom
        代码如下：
         public static void main(String[] args) {

                // 三大方法之一：创建指定的线程数
                ExecutorService threadPool = Executors.newFixedThreadPool(5);

                //三大方法之二：创建单个线程
                //ExecutorService threadPool = Executors.newSingleThreadExecutor();

                //三大方法之三：随之创建，遇强则强
                //ExecutorService threadPool = Executors.newCachedThreadPool();
                //使用线程池创建线程
                try {
                    for (int i = 0; i < 100; i++) {
                        threadPool.execute(()->{
                            System.out.println(Thread.currentThread().getName()+"ok");
                        });
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //使用完毕，关闭线程池
                    threadPool.shutdown();
                }
            }

七大参数：
    1.corePoolSize：   核心线程数，一直存活，即使线程数小于核心线程数的时候，
                       线程数有空闲，线程池也会创建新的线程。
    2.maximumPoolSize：最大线程数，当线程数大于核心线程数的时候并且任务队列已经满了的时候，
                       线程池会创建新的线程，当线程数大于最大线程数的时候并且任务队列已经满了，
                       会抛出异常。
    3.keepAliveTime：   线程空闲时间：当线程的空闲时间达到keepAliveTime时，线程会退出，
                       直到线程数等于核心线程数，如果allowCoreThreadTimeout=true，
                       则会直到线程数为0。
    4.TimeUnit unit    超时时间单位。

    5.BlockingQueue<Runnable> workQueue：
                        阻塞队列，任务队列的容量。

    6.ThreadFactory threadFactory：
                        线程工厂，基本不用设置。
    7.RejectedExecutionHandler handler：
                        拒绝策略，任务拒绝处理器。

  public ThreadPoolExecutor(   int corePoolSize,//核心线程数
                               int maximumPoolSize,//最大线程数
                               long keepAliveTime,//超时无人调用就会释放
                               TimeUnit unit,//超时时间单位
                               BlockingQueue<Runnable> workQueue,//阻塞队列
                               ThreadFactory threadFactory,//线程工厂-不用动
                               RejectedExecutionHandler handler)//拒绝策略 {
         if (corePoolSize < 0 ||
             maximumPoolSize <= 0 ||
             maximumPoolSize < corePoolSize ||
             keepAliveTime < 0)
             throw new IllegalArgumentException();
         if (workQueue == null || threadFactory == null || handler == null)
             throw new NullPointerException();
         this.corePoolSize = corePoolSize;
         this.maximumPoolSize = maximumPoolSize;
         this.workQueue = workQueue;
         this.keepAliveTime = unit.toNanos(keepAliveTime);
         this.threadFactory = threadFactory;
         this.handler = handler;
     }

四种拒绝策略：
        1.new ThreadPoolExecutor..AbortPolicy():线程池满了，还有线程想加入，不处理这个请求，跑出异常
        2.new ThreadPoolExecutor.CallerRunsPolicy()：如果任务被拒绝，则通过调用它线程执行此任务，哪来的回哪去
        3.new ThreadPoolExecutor.DiscardPolicy()：队列满了，丢掉任务，不会抛出异常
        4.new ThreadPoolExecutor.DiscardOldestPolicy()：队列满了，尝试去和最早的竞争，不会抛出异常

IO密集型，CPU密集型：（调优）
    public static void main(String[] args) {
       // 自定义线程池！工作 ThreadPoolExecutor
       // 最大线程到底该如何定义
       // 1、CPU 密集型，几核，就是几，可以保持CPu的效率最高！
       // 2、IO 密集型 > 判断你程序中十分耗IO的线程，
       // 程序 15个大型任务 io十分占用资源！
       // 获取CPU的核数
       System.out.println(Runtime.getRuntime().availableProcessors());
       ExecutorService threadPool = new ThreadPoolExecutor(
                             2,
                             Runtime.getRuntime().availableProcessors(),
                             3,
                             TimeUnit.SECONDS,
                             new LinkedBlockingDeque<>(3),
                             Executors.defaultThreadFactory(),
                             new ThreadPoolExecutor.DiscardOldestPolicy()); //队列满了，尝试去和
       最早的竞争，也不会抛出异常！
                try {
                    // 最大承载：Deque + max
                    // 超过 RejectedExecutionException
                    for (int i = 1; i <= 9; i++) {
                    // 使用了线程池之后，使用线程池来创建线程
                    threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                    });
                     }
                     } catch (Exception e) {
                            e.printStackTrace();
                     } finally {
                        // 线程池用完，程序结束，关闭线程池
                            threadPool.shutdown();
                   }
            }