JUC_线程池

谁借莪１个温暖的怀抱￠ 2023-07-03 03:21 9阅读 0赞

### 文章目录 ###

*  为什么使用线程池
 *  使用说明
 *   *  架构说明
     *  编码实现
     *   *  Executors.newFixedThreadPool(int)
         *  Executors.newSingleThreadExecutor()
         *  Executors.newCachedThreadPool()
 *  线程池七大参数
 *  线程池底层工作原理
 *  利用何种方法创建线程池
 *  拒绝策略
 *  如何合理配置线程池
 *   *  CPU密集型
     *  IO密集型

# 为什么使用线程池 #

线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

它的主要特点为：**线程复用;控制最大并发数;管理线程。**

*  降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
 *  提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。
 *  提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

# 使用说明 #

## 架构说明 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70]

## 编码实现 ##

### Executors.newFixedThreadPool(int) ###

执行长期任务性能好，创建一个线程池，一池有N个固定的线程，有固定线程数的线程

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

newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的是LinkedBlockingQueue。

### Executors.newSingleThreadExecutor() ###

一个任务一个任务的执行，一池一线程

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

newSingleThreadExecutor 创建的线程池corePoolSize和maximumPoolSize值都是1，它使用的是LinkedBlockingQueue

### Executors.newCachedThreadPool() ###

执行很多短期异步任务，线程池根据需要创建新线程，但在先前构建的线程可用时将重用它们。可扩容，遇强则强

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

newCachedThreadPool创建的线程池将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX\_VALUE，它使用的是SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程。

# 线程池七大参数 #

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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

1.  corePoolSize：线程池中的常驻核心线程数
2.  maximumPoolSize：线程池中能够容纳同时执行的最大线程数，此值必须大于等于1
3.  keepAliveTime：多余的空闲线程的存活时间,当前池中线程数量超过corePoolSize时，当空闲时间,达到keepAliveTime时，多余线程会被销毁直到,只剩下corePoolSize个线程为止
4.  unit：keepAliveTime的单位
5.  workQueue：任务队列，被提交但尚未被执行的任务
6.  threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可
7.  handler：拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时如何来拒绝请求执行的runnable的策略

# 线程池底层工作原理 #

1.  线程池创建之后，等待请求
2.  当调用execute()方法添加一个请求任务时，线程池将作出以下判断：
    
    1.  如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务
    2.  如果正在运行的线程数量大于等于corePoolSize，那么将这个任务放入队列
    3.  如果队列已满并且运行的线程数量小于maximumPoolSize，则创建非核心线程立刻执行这个任务
    4.  如果队列满了，且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行
3.  当一个线程完成任务时，它会从队列中取下一个任务来执行
4.  当一个线程空闲超过keepAlivetime时，会做以下判断：
    
    1.  如果当前运行线程数量大于corePoolSize，那么这个线程将被停掉。所有任务完成后，最终会收缩到corePoolSize的大小。

# 利用何种方法创建线程池 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 1]

ExecutorService threadPool = new ThreadPoolExecutor(
            2,
            5,
            2L,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(3),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.DiscardOldestPolicy()
    );

# 拒绝策略 #

*  AbortPolicy(默认):直接抛出`RejectedException`异常阻止系统正常运行
 *  CallerRunPolicy:"调用者运行"一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将任务回退到调用者，从而降低新任务的流量
 *  DiscardOldestPolicy:抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交
 *  DiscardPolicy:直接丢弃任务,不予任何处理也不抛出异常.如果允许任务丢失,这是最好的拒绝策略

# 如何合理配置线程池 #

[https://blog.csdn.net/Chill\_Lyn/article/details/106878028][https_blog.csdn.net_Chill_Lyn_article_details_106878028]

## CPU密集型 ##

//查看CPU核数
    System.out.println(Runtime.getRuntime().availableProcessors());

任务需要大量的运算，且没有阻塞，CPU一直全速运行，这种情况下应该尽可能减少线程之间上下文切换带来的开销，一般为`CPU核数+1`

## IO密集型 ##

任务需要大量的IO，即大量的阻塞。在单线程上运行IO密集型任务会导致浪费大量的CPU运算能力在等待。所以在IO密集型任务重使用多线程可以大大加速程序运行，即使再单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。

线程数=CPU核数×（1/CPU利用率）=CPU核数×[1+（IO耗时/CPU耗时）]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200510211226667.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200510220509371.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_Chill_Lyn_article_details_106878028]: https://blog.csdn.net/Chill_Lyn/article/details/106878028