线程池创建的核心：1.三大方法 2.七大参数 3.四大拒绝策略

  线程池创建的核心：
       三大方法：
           1.Executors.newSingleThreadExecutor();
           2.Executors.newFixedThreadPool(5);
           3.Executors.newCachedThreadPool();
       七大参数：（自定义创建线程池）
           1.核心线程数
           2.最大线程数
           3.等待时间
           4.等待时间单位
           5.阻塞队列
           6.线程池创建工场
           7.拒绝策略
       四大拒绝策略：
           AbortPolicy;  队列和线程池满了之和就会抛出异常
            CallerRunsPolicy;  哪来的回哪里去
            DiscardOldestPolicy;  满了之后不会抛出异常，丢掉任务
            DiscardPolicy  满了之后尝试竞争第一个，失败也不抛异常

 线程池最大值如何设置：
   1.CPU密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
        获得cpu的核数，不同的硬件不一样
   2.IO密集型
       大型的程序任务有多少个？ IO非常消耗资源
       线程池最大值 > 大型任务的数量即可
       一般设置大型任务的数量*2

package cn.pw.demo01;

import java.util.concurrent.*;


/*  线程池创建的核心：
*       三大方法：
*           1.Executors.newSingleThreadExecutor();
*           2.Executors.newFixedThreadPool(5);
*           3.Executors.newCachedThreadPool();
*       七大参数：（自定义创建线程池）
*           1.核心线程数
*           2.最大线程数
*           3.等待时间
*           4.等待时间单位
*           5.阻塞队列
*           6.线程池创建工场
*           7.拒绝策略
*       四大拒绝策略：
*           AbortPolicy;  队列和线程池满了之和就会抛出异常
            CallerRunsPolicy;  哪来的回哪里去
            DiscardOldestPolicy;  满了之后不会抛出异常，丢掉任务
            DiscardPolicy  满了之后尝试竞争第一个，失败也不抛异常

* 线程池最大值如何设置：
*   1.CPU密集型
*        System.out.println(Runtime.getRuntime().availableProcessors());
*        获得cpu的核数，不同的硬件不一样
*   2.IO密集型
*       大型的程序任务有多少个？ IO非常消耗资源
*       线程池最大值 > 大型任务的数量即可
*       一般设置大型任务的数量*2
*
* * */
public class Test07ThreadPool {
    public static void main(String[] args) {

        //单线程池
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        //创建一个线程池中可以有5条线程
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        //缓存线程池，不固定大小
//        ExecutorService threadPool = Executors.newCachedThreadPool();


//        try {
//            for (int i = 0; i < 50; i++) {
//                threadPool.execute(()->{
//                    System.out.println(Thread.currentThread().getName()+"ok");
//                });
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            //关闭线程池
//            threadPool.shutdown();
//        }

        //源生的线程池创建

//    public ThreadPoolExecutor(int corePoolSize,//核心线程数
//        int maximumPoolSize,  //最大线程数
//        long keepAliveTime, //空闲线程的等待时间
//        TimeUnit unit, //时间单位
//        BlockingQueue<Runnable> workQueue //线程队列 ) {
//            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
//                    Executors.defaultThreadFactory(), defaultHandler);
//        }

//        四种拒绝策列
//       AbortPolicy;  队列和线程池满了之和就会抛出异常
//       CallerRunsPolicy;  哪来的回哪里去
//       DiscardOldestPolicy;  满了之后不会抛出异常，丢掉任务
//       DiscardPolicy  满了之后尝试竞争第一个，失败也不抛异常
            ThreadPoolExecutor threadPool= new ThreadPoolExecutor(
                    2,//核心线程数
                    Runtime.getRuntime().availableProcessors(),//最大线程数
                    3,//等待时间
                    TimeUnit.SECONDS,//时间单位
                    new LinkedBlockingQueue<>(3),//等待队列
                    Executors.defaultThreadFactory(),//默认线程工场，一般不改变
                    new ThreadPoolExecutor.DiscardOldestPolicy()//线程和队列满了的拒绝策列
                    );

            try {
                //线程池大小= 最大线程数+ 阻塞队列大小
                for (int i = 1; i <= 9; i++) {
                    threadPool.execute(()->{
                        System.out.println(Thread.currentThread().getName()+"ok");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //关闭线程池
                threadPool.shutdown();
            }

    }
}