线程池（三七四）

线程池

线程池：三大方法。七大参数。4种拒绝策略

池化技术；
程序的运行，是占用系统的资源的！ 优化资源的使用，===>池化技术；
线程池，连接池，内存池，对象池…创建 ，销毁，十分的浪费资源。。
池化技术：事先准备好一些资源，有人要用，就在这里来拿，用完之后还给我。

线程池的好处：
1：降低资源的消耗。
2：提高响应的速率。
3：方便管理。
线程的复用，可以控制最大的并发量，管理线程；

三大方法:

//ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
//ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池大小;
//ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的,

七大参数：

public ThreadPoolExecutor(int corePoolSize,   //可以同时进行的大小
                              int maximumPoolSize,  //最大的容量大小  
                              long keepAliveTime,  //等待时长
                              TimeUnit unit,  //等待时长的单位
                              BlockingQueue<Runnable> workQueue,  //候客区的大小；
                              ThreadFactory threadFactory,  // 默认的执行器;
                              RejectedExecutionHandler handler)   //四种拒绝策略；

四种拒绝策略

4四种拒绝策略

---

• 1:new ThreadPoolExecutor.AbortPolicy() // 银行满了,还有人要进来,不处理这个人,抛出异常.
• 2:new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里;
• 3:new ThreadPoolExecutor.DiscardPolicy() //队列满了,不会抛出异常.
• 4:new ThreadPoolExecutor.DiscardOldestPolicy()

•        被拒绝任务的处理程序，丢弃最旧的未处理任请求，然后重试{@code execute}，
  

•         除非执行器被关闭，在这种情况下，任务被丢弃。
  

package com.baidu.pool;

import java.util.concurrent.*;

/**
 * 4四种拒绝策略
 * 1:new ThreadPoolExecutor.AbortPolicy()  // 银行满了,还有人要进来,不处理这个人,抛出异常.
 * 2:new ThreadPoolExecutor.CallerRunsPolicy()  // 哪来的去哪里;
 * 3:new ThreadPoolExecutor.DiscardPolicy() //队列满了,不会抛出异常.
 * 4:new ThreadPoolExecutor.DiscardOldestPolicy()
 *                 //被拒绝任务的处理程序，丢弃最旧的未处理任请求，然后重试{@code execute}，
 *                 // 除非执行器被关闭，在这种情况下，任务被丢弃。
 */
public class Demo01 {

    public static void main(String[] args) {
        //自定义线程池

        //三大方法；
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);  // 创建一个固定的线程池大小;
        //ExecutorService threadPool = Executors.newCachedThreadPool();  // 可伸缩的,


        /*
        最大的线程到底该如何定义那;
        1:CPU 密集型,电脑是几核的,就是几.可以保持CPU 的效率最高;
        2:IO 密集型 判断你的程序十分耗IO的线程, 设置成它的2 倍,就差不多了...15个大型的任务, 设置成30;;
         */


        //ThreadPoolExecutor的七大参数
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,  //可以同时进行的大小
                Runtime.getRuntime().availableProcessors(),// 代码获得本机电脑的几核;  //最大的容量大小
                3,  //等待时长
                TimeUnit.SECONDS,  // 等待单位
                new LinkedBlockingDeque<>(3),  //候客区的大小;
                Executors.defaultThreadFactory(), // 默认的执行器;
                new ThreadPoolExecutor.DiscardOldestPolicy() //也不会抛出异常
                //被拒绝任务的处理程序，丢弃最旧的未处理任请求，然后重试{@code execute}，
                // 除非执行器被关闭，在这种情况下，任务被丢弃。
        );

        try {

            //最大承载数:Max +  LinkedBlockingDeque,超出最大承载数,抛出异常
            //java.util.concurrent.RejectedExecutionException:
            for (int i = 1; i <= 10; i++) {
                //使用线程池之后,使用线程池来创建线程;
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+":OK");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完之后,程序结束,关闭线程池,
            threadPool.shutdown();
        }


    }
}