ThreadPoolExecutor 线程池 三大方法 七大参数

> 池化技术

程序的运行，本质是占用系统资源，优化资源的使用。

池化技术：事先准备好的一些资源，用就来拿

**好处**：

1.降低资源消耗

2.提高响应速度

3.方便管理

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

三大方法

package com.pa.test.JUC.pool;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorsPoolTest {
    public static void main(String[] args) {
//三大方法
//        ExecutorService executorService = Executors.newSingleThreadExecutor();
//        ExecutorService executorService = Executors.newFixedThreadPool(5);
        ExecutorService executorService = Executors.newCachedThreadPool();

        try {
            for (int i = 0; i < 100; i++) {
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序执行结束，关闭线程池
            executorService.shutdown();
        }
    }
}

new ThreadPoolExecutor()自定义创建

corePoolSize：核心池的大小，表示最多可执行几条线程，超出的线程会放到缓存中去等待；

maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；

keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

workQueue：一个阻塞队列，用来存储等待执行的任务，缓存没有执行的线程，一般来说，这里的阻塞队列有以下几种选择：

ArrayBlockingQueue
LinkedBlockingQueue
SynchronousQueue
PriorityBlockingQueue

ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和SynchronousQueue。线程池的排队策略与BlockingQueue有关。

threadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程做些更有意义的事情，比如设置daemon和优先级等等 handler：表示当拒绝处理任务时的策略，有以下四种取值：

1、AbortPolicy：直接抛出异常。
2、CallerRunsPolicy：只用调用者所在线程来运行任务，比如main线程执行。
3、DiscardOldestPolicy：尝试去和最早的竞争。
4、DiscardPolicy：不处理，丢弃掉。
5、也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

相当于银行办理业务，总共设有maximumPoolSize个窗口，但是只有corePoolSize个窗口可以办理业务，workQueue就是在候客区排队等着叫号

七大参数 源码

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;
    }

示例：

package com.pa.test.JUC.pool;


import java.util.concurrent.*;

public class ExecutorsPoolTest {
    public static void main(String[] args) {

//        ExecutorService executorService = Executors.newSingleThreadExecutor();
//        ExecutorService executorService = Executors.newFixedThreadPool(5);
//        ExecutorService executorService = Executors.newCachedThreadPool();
        ThreadPoolExecutor executorService = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                (new LinkedBlockingDeque<>(2)),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        executorService.execute(() -> {

        });
        try {
            for (int i = 1; i < 10; i++) {
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序执行结束，关闭线程池
            executorService.shutdown();
        }
    }
}

了解：IO密集型， CPU密集型（调优）

最大线程池如何定义：

//cpu密集型，几核就是几，可以保持cpu的效率最高
Runtime.getRuntime().availableProcessors()

IO密集型， 判断程序中十分消耗资源的IO线程

程序 15个IO任务 十分消耗资源