04 线程池

线程池（重点）

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

池化技术

程序的运行，本质：占用系统的资源！优化资源的使用！ >> 池化技术

线程池、连接池、内存池、对象池创建、销毁，十分浪费资源

池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我

线程池的好处：

降低资源的消耗
提高响应的速度
方便管理

线程复用、可以控制最大并发数、管理线程

Executors 工具类 3大方法

//        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
            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();
        }

7大参数

源码分析

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

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

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

//本质 ThreadPoolExecutor

 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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

手动创建一个线程池

手动创建线程池

 //自定义线程！ 工作 ThreadPoolExecutor
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2,
                                                                5,
                                                                3,
                                                                 TimeUnit.SECONDS,
                                                                 new LinkedBlockingQueue<>(3),
                                                                 Executors.defaultThreadFactory(),
                                                                 new ThreadPoolExecutor.AbortPolicy()
        );


        try {
            //最大承载：Queue + 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();
        }

    }

四种拒绝策略

//new ThreadPoolExecutor.AbortPolicy()//银行满了，还有人进来，不处理这个人的，抛出异常
//new ThreadPoolExecutor.CallerRunsPolicy()//哪里来的去哪里 让main线程执行
//new ThreadPoolExecutor.DiscardPolicy()//队列满了，丢掉任务，不会抛出异常
//new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了，刨抛弃队列里面最老的那个，代替它的位置进入队列，不会抛出异常

最大线程到底如何定义

CPU 密集型，几核，就是几，可以保持CPU效率最高
IO 密集型 > 判断你程序种十分耗IO的线程，

//获取CPU的核数
        System.out.println(Runtime.getRuntime().availableProcessors());

 //自定义线程！ 工作 ThreadPoolExecutor
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2,
                                                               Runtime.getRuntime().availableProcessors(),//获取cpu核数
                                                               																 
                                                               3,                                            												 
                                                               TimeUnit.SECONDS,
                                                               new LinkedBlockingQueue<>(3),
                                                                 								 
                                                               Executors.defaultThreadFactory(),
                                                               new ThreadPoolExecutor.AbortPolicy()
        );