線程池創建的核心：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();
            }

    }
}