JUC并发包-线程池

最新推荐文章于 2022-09-19 00:05:16 发布

旭出东方旭出东方旭出东方旭出东方旭出东方

最新推荐文章于 2022-09-19 00:05:16 发布

阅读量133

点赞数

分类专栏：多线程 java

本文链接：https://blog.csdn.net/u013720069/article/details/116402935

版权

java 同时被 2 个专栏收录

22 篇文章 1 订阅

订阅专栏

多线程

5 篇文章 0 订阅

订阅专栏

为了更好的控制多线程，JDK提供了一套线程框架Executor，帮助开发人员有效的进行线程控制。它们都在java.util.concurrent包中，是JDK并发包的核心。其中有一个比较重要的类：Executors，他扮演这线程工厂的角色，我们通过Executors可以创建特定功能的线程池。

什么是线程池

Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序
都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。

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

线程池作用

线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，减少了创建和销毁线程所需的时间，从而提高效率。
如果一个线程的时间非常长，就没必要用线程池了(不是不能作长时间操作，而是不宜。)，况且我们还不能控制线程池中线程的开始、挂起、和中止。

线程池四种创建方式

newFixedThreadPool()可控最大并发数线程池

该方法返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中等待有空闲的线程去执行。

newSingleThreadExecutors()单线程化线程池

单线程化线程池(newSingleThreadExecutor)的优点，串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

newCachedThreadPool()可回收缓存线程池

返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若用空闲的线程则执行任务，若无任务则不创建线程。并且每一个空闲线程会在60秒后自动回收。
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

// 无限大小线程池jvm自动回收
    ExecutorServicenewCachedThreadPool = Executors.newCachedThreadPool();
     for (inti = 0; i< 10; i++) {
       finalinttemp = i;
       newCachedThreadPool.execute(new Runnable() {
          @Override
          publicvoid run() {
            try {
               Thread.sleep(100);
            } catch (Exception e) {
               // TODO: handle exception
            }
            System.out.println(Thread.currentThread().getName() + ",i:" + temp);
 
          }
       });
     }

总结: 线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

newScheduledThreadPool()支持定时与周期性任务的线程池

newScheduledThreadPool线程池类型也是经常用到的，它可以和newFixedThreadPool类型一样设置并发数量。同时其还支持定时及周期任务执行，因此它常是用于定时任务打当中。

package com.zhw.learning.thread;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @author zhw
 * 创建一个可定期或者延时执行任务的定长线程池，支持定时及周期性任务执行
 *
 * Executors.newScheduledThreadPool(3):
 * public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
 *         return new ScheduledThreadPoolExecutor(corePoolSize);
 *     }
 * public ScheduledThreadPoolExecutor(int corePoolSize) {
 *         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
 *               new DelayedWorkQueue());
 *     }
 */
public class ScheduledThreadPoolTest {

    public static void main(String[] args) throws InterruptedException {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

        System.out.println("提交时间: " + sdf.format(new Date()));

        //延迟3秒钟后执行任务
//        scheduledThreadPool.schedule(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("运行时间: " + sdf.format(new Date()));
//            }
//        }, 3, TimeUnit.SECONDS);

        //延迟1秒钟后每隔3秒执行一次任务
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("运行时间: " + sdf.format(new Date()));
            }
        }, 1, 3, TimeUnit.SECONDS);
        Thread.sleep(10000);

        scheduledThreadPool.shutdown();
    }

}

自定义线程池

若Executors工厂类无法满足我们的需求，可以自己去创建自定义的线程池，其实Executors工厂类里面创建线程的方法其内部实现均是用了ThreadPoolExecutors这个类，这个类可以自定义线程。构造方法如下：

public ThreadPoolExecutor(int corePoolSize,
                               int maximumPoolSize,
                               long keepAliveTime,
                               TimeUnit unit,
                               BlockingQueue<Runnable> workQueue,
                               ThreadFactory threadFactory,
                               RejectedExecutionHandler handler){...}

使用有界队列

在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，若大于corePoolSize，则会将任务加入队列，若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。

任务类

public class MyTask implements Runnable {
 
  private int taskId;
  private String taskName;
  public MyTask(int taskId, String taskName){
     this.taskId = taskId;
     this.taskName = taskName;
  }
  public int getTaskId() {
     return taskId;
  }
  public void setTaskId(int taskId) {
     this.taskId = taskId;
  }
  public String getTaskName() {
     return taskName;
  }
  public void setTaskName(String taskName) {
     this.taskName = taskName;
  }
  @Override
  public void run() {
     try {
       System.out.println("run taskId =" + this.taskId);
       Thread.sleep(5*1000);
       //System.out.println("end taskId =" + this.taskId);
     } catch (InterruptedException e) {
       e.printStackTrace();
     }    
  }
  public String toString(){
     return Integer.toString(this.taskId);
  }
}

拒绝响应类

public class MyRejected implements RejectedExecutionHandler{
  public MyRejected(){
  }
  @Override
  public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
     //可以记录日志
     //
     System.out.println("自定义处理..");
     System.out.println("当前被拒绝任务为：" + r.toString());
  }
}

测试类

public class UseThreadPoolExecutor1 {
  public static void main(String[] args) {
     /**
      * 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
      * 若大于corePoolSize，则会将任务加入队列，
      * 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
      * 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
      * 
      */  
     ThreadPoolExecutor pool = new ThreadPoolExecutor(
          1,          //coreSize
          2,          //MaxSize
          60,       //60
          TimeUnit.SECONDS, 
          new ArrayBlockingQueue<Runnable>(3)       //指定一种队列 （有界队列）
          //new LinkedBlockingQueue<Runnable>()
          , new MyRejected()
          //, new DiscardOldestPolicy()
          );
     
     MyTask mt1 = new MyTask(1, "任务1");直接获取线程执行
     MyTask mt2 = new MyTask(2, "任务2");放在队列中
     MyTask mt3 = new MyTask(3, "任务3");放在队列中
     MyTask mt4 = new MyTask(4, "任务4");放在队列中
     MyTask mt5 = new MyTask(5, "任务5");创建新的线程执行
     MyTask mt6 = new MyTask(6, "任务6");拒绝
     
     pool.execute(mt1);
     pool.execute(mt2);
     pool.execute(mt3);
     pool.execute(mt4);
     pool.execute(mt5);
     pool.execute(mt6);
     
     pool.shutdown();
     
  }
}

执行结果
在这里插入图片描述

使用无界队列

无界的任务队列时：LinkedBlockingQueue。与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入列失败的情况。当有新任务到来，系统的线程数小于corePoolSize时，则新建线程执行任务。当达到corePoolSize后，就不会继续增加。若后续仍有新的任务加入，而没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。
JDK拒绝策略：
AbortPolicy：直接抛出异常组织系统正常工作
CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。
DiscareOldestPolicy：丢弃最后的一个请求，尝试再次提交当前任务。
DiscardPolicy：丢弃无法处理的任务，不给于任何处理。
如果需要自定义拒绝策略可以实现RejectedExecutionHandler接口

合理配置线程池

CPU密集

CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。
CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程)，而在单核CPU上，无论你开几个模拟的多线程，该任务都不可能得到加速，因为CPU总的运算能力就那些。

IO密集

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

要想合理的配置线程池的大小，首先得分析任务的特性，可以从以下几个角度分析：

任务的性质：CPU密集型任务、IO密集型任务、混合型任务。
任务的优先级：高、中、低。
任务的执行时间：长、中、短。
任务的依赖性：是否依赖其他系统资源，如数据库连接等。

性质不同的任务可以交给不同规模的线程池执行。
对于不同性质的任务来说，CPU密集型任务应配置尽可能小的线程，如配置CPU个数+1的线程数，IO密集型任务应配置尽可能多的线程，因为IO操作不占用CPU，不要让CPU闲下来，应加大线程数量，如配置两倍CPU个数+1，而对于混合型的任务，如果可以拆分，拆分成IO密集型和CPU密集型分别处理，前提是两者运行的时间是差不多的，如果处理时间相差很大，则没必要拆分了。
若任务对其他系统资源有依赖，如某个任务依赖数据库的连接返回的结果，这时候等待的时间越长，则CPU空闲的时间越长，那么线程数量应设置得越大，才能更好的利用CPU。
当然具体合理线程池值大小，需要结合系统实际情况，在大量的尝试下比较才能得出，以上只是前人总结的规律。

最佳线程数目 = （（线程等待时间+线程CPU时间）/线程CPU时间）* CPU数目
比如平均每个线程CPU运行时间为0.5s，而线程等待时间（非CPU运行时间，比如IO）为1.5s，CPU核心数为8，那么根据上面这个公式估算得到：((0.5+1.5)/0.5)8=32。这个公式进一步转化为：
最佳线程数目 = （线程等待时间与线程CPU时间之比 + 1） CPU数目
可以得出一个结论：
线程等待时间所占比例越高，需要越多线程。线程CPU时间所占比例越高，需要越少线程。
以上公式与之前的CPU和IO密集型任务设置线程数基本吻合。
CPU密集型时，任务可以少配置线程数，大概和机器的cpu核数相当，这样可以使得每个线程都在执行任务
IO密集型时，大部分线程都阻塞，故需要多配置线程数，2*cpu核数
操作系统之名称解释：
某些进程花费了绝大多数时间在计算上，而其他则在等待I/O上花费了大多是时间，
前者称为计算密集型（CPU密集型）computer-bound，后者称为I/O密集型，I/O-bound。