第二十七章 线程池ThreadPool基本使用

转载于https://juejin.im/post/5f059e53f265da230a123cab

一、适用场景:

为突然大量爆发的线程设计的,通过有限固定线程提高线程的利用效率,减少了创建和销毁线程所需的时间,方便管理线程。 ThreadPool适于并发运行和运行时间不长且互不干扰的函数。

二、不适用场景:

  • 线程执行需要很长时间
  • 需要为线程指定详细的优先级
  • 在执行过程中需要对线程进行操作,比如睡眠、挂起等

二、作用&优势

1.线程复用

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

三、线程池的使用

1.ThreadPoolExecutor是线程池的真正实现类,通过ThreadPoolExecutor来创建一个线程池

// 通过构造方法&配置核心参数,创建线程池对象
Executor threadPool = new ThreadPoolExecutor( CORE_POOL_SIZE , MAXIMUM_POOL_SIZE , 
                                            KEEP_ALIVE , TimeUnit.SECONDS,  
                                            sPoolWorkQueue , sThreadFactory );
//构造函数源码分析
new ThreadPoolExecutor(int corePoolSize,    //核心线程数
                       int maximumPoolSize, //线程池最大线程数
                       long keepAliveTime,  //线程活动保持时间
                       TimeUnit unit,       //线程活动保持时间单位
                       BlockingQueue workQueue,  //任务队列
                       ThreadFactory threadFactory);  //线程工厂

2.线程池参数说明

  • corePoolSize:核心线程数。默认情况下,核心线程会一直存活(包括空闲状态)。当提交一个任务到线程池时,线程池会创建一个线程来执行任务,即使其他空闲的核心线程能够执行新任务也会创建线程,等到需要执行的任务数大于corePoolSize(线程池核心线程数)时就不会再创建了。
  • maximumPoolSize:线程池最大线程数。如果队列满了,并且已创建的线程数小于maximumPoolSize(线程池最大线程数),则线程池会再创建新的线程执行任务;当活动线程数达到maximumPoolSize(线程池最大线程数)后,后续的新任务将会阻塞。
  • keepAliveTime:线程活动保持时间。默认情况下,该时间为非核心线程闲置后,保存存活的时间。当allowCoreThreadTimeout设置为true时,该时间同样作用于核心线程。当超过该时间,空闲的工作线程就会被回收。(如果任务很多,并且每个任务执行的时间比较短,可以调大该时间,提高线程的利用率)。
  • unit:keepAliveTime参数的时间单位(线程活动保持时间单位)。常用单位有小时(HOURS)、分(MINUTES)、秒(SECONDS)、毫秒(MILLISECONDS)。
  • workQueue:任务队列。属于阻塞队列BlockQueue类型,即当队列为空时,此时取出任务的操作会被阻塞;当队列满时,添加任务也会被被阻塞。通过线程池的execute()方法提交的Runnable对象,将存储在该参数中。
  • theadFactory:线程工厂。为线程池创建新线程。我们一般使用默认即可。

3.线程池执行

a.使用execute提交任务,execute方法没有返回值,所以无法判断任务是否被线程池执行成功

//向线程池提交任务:execute()
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        ... // 线程执行任务
       }
});

b.使用submit()方法来提交任务,它会返回一个future,那么可以通过future来判断任务是否执行成功,future的get方法获取返回值,get方法会阻塞直到任务完成

Future future = threadPool.submit(harReturnValuetask);
try {
     Object o = future.get();
} catch (InterruptedException e) {
    // 处理中断异常
} catch (ExecutionException e) {
    // 处理无法执行任务异常
} finally {
    // 关闭线程池
    threadPool.shutdown();
}

4.线程池关闭

//关闭线程池shutdown() 
threadPool.shutdown();
//或者threadPool.shutdownNow(); 

a.原理:

通过调用线程池的shutdown或shutdownNow方法来关闭线程池,它们的原理是遍历线程池中的工作线程,然后逐个调用线程的interrupt方法来中断线程,所以无法响应中断的任务可能永远无法终止

b.区别:

shutdownNow首先将线程池的状态设置成STOP,然后尝试停止所有的正在执行或暂停任务的线程,并返回等待执行任务的列表; shutdown只是将线程池的状态设置成SHUTDOWN状态,然后中断所有没有正在执行任务的线程。

c.选择:

3)选择
只要调用了这两个关闭方法的其中一个,isShutdown方法就会返回true。当所有的任务都已关闭后,才表示线程池关闭成功,这时调用isTerminaed方法会返回true。至于我们应该调用哪一种方法来关闭线程池,应该由提交到线程池的任务特性决定,通常调用shutdown()来关闭线程池,如果任务不一定要执行完,则可以调用shutdownNow()来关闭线程池。

四、合理的配置线程池

1.任务的性质:CPU密集型任务、IO密集型任务和混合型任务。
2.任务的优先级:高、中和低。
3.任务的执行时间:长、中和短。
4.任务的依赖性:是否依赖其他系统资源,如数据库连接。

  • 性质不同的任务:可以用不同规模的线程池分开处理。CPU密集型任务配置尽可能小的线程,如配置Ncpu+1个线程的线程池;IO密集型任务则由于线程并不是一直在执行任务,则配置尽可能多的线程,如2*Ncpu;混合型的任务,如果可以拆分,则将其拆分成一个CPU密集型任务和一个IO密集型任务,只要这两个任务执行的时间相差不是太大,那么分解后执行的吞吐率要高于串行执行的吞吐率,如果这两个任务执行时间相差太大,则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。比如:
corePoolSize = Runtime.getRuntime().availableProcessors() + 1
maximumPoolSize = Runtime.getRuntime().availableProcessors() * 2 + 1 
  • 优先级不同的任务:可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先得到执行,需要注意的是如果一直有优先级高的任务提交到队列里,那么优先级低的任务可能永远不能执行。
  • 执行时间不同的任务可以交给不同规模的线程池来处理,或者也可以使用优先级队列,让执行时间短的任务先执行。
  • 依赖数据库连接池的任务,因为线程提交SQL后需要等待数据库返回结果,如果等待的时间越长CPU空闲时间就越长,那么线程数应该设置越大,这样才能更好的利用CPU。

五、工作流程

QQ截图20200714104347.jpg

当线程池中的线程数量 > 核心线程数(corePoolSize)时,若某线程(非核心线程)的空闲时间 > 闲置超时时长(keepAliveTime) 线程将被终止。通过这样的策略,线程池可动态调整池中的线程数。

六、常见线程池分类

  • 定长线程池(FixedThreadPool)
  • 定时线程池(ScheduledThreadPool )
  • 可缓存线程池(CachedThreadPool)
  • 单线程化线程池(SingleThreadExecutor)
1.定长线程池(FixedThreadPool)

特点:只有核心线程 & 不会被回收、线程数量固定、任务队列无大小限制(超出的线程任务会在队列中等待)
应用场景:控制线程最大并发数
具体使用:通过Executors.newFixedThreadPool()创建

// 1. 创建定长线程池对象 & 设置线程池线程数量固定为3
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run(){
    System.out.println("执行任务啦");
     }
    };

// 3. 向线程池提交任务:execute()
fixedThreadPool.execute(task);

// 4. 关闭线程池
fixedThreadPool.shutdown();
2.定时线程池(ScheduledThreadPool )

特点:核心线程数量固定、非核心线程数量无限制(闲置时马上回收)
应用场景:执行定时 / 周期性 任务
使用:通过Executors.newScheduledThreadPool()创建
示例:

// 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
       public void run(){
              System.out.println("执行任务啦");
          }
    };
// 3. 向线程池提交任务:schedule()
scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务
scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务
// 4. 关闭线程池
scheduledThreadPool.shutdown();
3.可缓存线程池(CachedThreadPool)

特点:只有非核心线程、线程数量不固定(可无限大)、灵活回收空闲线程(具备超时机制,全部回收时几乎不占系统资源)、新建线程(无线程可用时);任何线程任务到来都会立刻执行,不需要等待
应用场景:执行大量、耗时少的线程任务
使用:通过Executors.newCachedThreadPool()创建
示例:

// 1. 创建可缓存线程池对象
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run(){
        System.out.println("执行任务啦");
    }
  };

// 3. 向线程池提交任务:execute()
cachedThreadPool.execute(task);

// 4. 关闭线程池
cachedThreadPool.shutdown();

//当执行第二个任务时第一个任务已经完成
//那么会复用执行第一个任务的线程,而不用每次新建线程。

4.单线程化线程池(SingleThreadExecutor)

特点:只有一个核心线程(保证所有任务按照指定顺序在一个线程中执行,不需要处理线程同步的问题)
应用场景:不适合并发但可能引起IO阻塞性及影响UI线程响应的操作,如数据库操作,文件操作等
使用:通过Executors.newSingleThreadExecutor()创建
示例:

// 1. 创建单线程化线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run(){
        System.out.println("执行任务啦");
    }
  };

// 3. 向线程池提交任务:execute()
singleThreadExecutor.execute(task);

// 4. 关闭线程池
singleThreadExecutor.shutdown();

六、线程池的监控

通过线程池提供的参数进行监控。线程池里有一些属性在监控线程池的时候可以使用。

taskCount:线程池需要执行的任务数量。
completedTaskCount:线程池在运行过程中已完成的任务数量。小于或等于taskCount。
largestPoolSize:线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小,则表示线程池曾经满了。
getPoolSize:线程池的线程数量。如果线程池不销毁的话,池里的线程不会自动销毁,所以这个大小只增不减。
getActiveCount:获取活动的线程数。

通过继承线程池并重写线程池的beforeExecute,afterExecute和terminated方法,我们可以在任务执行前,执行后和线程池关闭前干一些事情。如监控任务的平均执行时间,最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如:

protected void beforeExecute(Thread t, Runnable r) { }

你可能感兴趣的:(第二十七章 线程池ThreadPool基本使用)