java线程池

1. 概述

线程池就是有效使用线程的一种常用方式. 线程池内部可以预先 创建一定数量的工作线程,客户端代码直接将任务作为一个对象提交 给线程池, 线程池将这些任务缓存在工作队列中, 线程池中的工作线 程不断地从队列中取出任务并执行。

线程池工作流程示意图：

2. JDK 对线程池的支持

JDK 提供了一套 Executor 框架,可以帮助开发人员有效的使用线程池

public class ThreadPool {
	
	public static void main(String[] args) {
		
		// 创建五个线程大小的线程池
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
		// 向线程池提交18个任务，存储到线程池的阻塞队列，线程池中这 5 个线程就从阻塞队列中取任务执行
		for (int i = 0; i < 18; i++) {
			fixedThreadPool.execute(new Runnable() {
				// 
				public void run() {
					System.out.println(Thread.currentThread().getId() + 
							" 编号的任务在执 行任务,开始时间: " + System.currentTimeMillis());
					try {
						Thread.sleep(3000); // 模拟任务执行时长
					} catch (InterruptedException e) {
						e.printStackTrace();
					} 
				}
				
			});
		}
	}

}

3. 线程池的底层实现

查 看 Executors 工 具 类 中 newCachedThreadPool(), newSingleThreadExcecutor(), newFixedThreadPool()源码:

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

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

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }  
// ThreadPoolExecutor的构造方法
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

Excutors 工 具 类 中 返 回 线 程 池 的 方 法 底 层 都 使 用 了 ThreadPoolExecutor 线程池,这些方法都是 ThreadPoolExecutor 线程池 的封装.

各个参数含义:

• corePoolSize, 指定线程池中核心线程的数量
• maxinumPoolSize,指定线程池中最大线程数量
• keepAliveTime,当线程池线程的数量超过 corePoolSize 时,多余的空 闲线程的存活时长,即空闲线程在多长时长内销毁
• unit, 是 keepAliveTime 时长单位
• workQueue,任务队列,把任务提交到该任务队列中等待执行
• threadFactory,线程工厂,用于创建线程
• handler 拒绝策略,当任务太多来不及处理时,如何拒绝

说明: workQueue 工 作 队 列 是 指 提 交 未 执 行 的 任 务 队 列 , 它 是 BlockingQueue 接口的对象,仅用于存储 Runnable 任务.根据队列功能分类,在 ThreadPoolExecutor 构造方法中可以使用以下几种阻塞队列:

• 直接提交队列,由 SynchronousQueue 对象提供,该队列没有 容量,提交给线程池的任务不会被真实的保存,总是将新的任务提交给线程执行,如果没有空闲线程,则尝试创建新的线程,如果线程 数量已经达到 maxinumPoolSize 规定的最大值则执行拒绝策略。
• 有界任务队列 , 由 ArrayBlockingQueue 实 现 , 在创建 ArrayBlockingQueue 对象时,可以指定一个容量. 当有任务需要执 行时,如果线程池中线程数小于 corePoolSize 核心线程数则创建新 的线程;如果大于 corePoolSize 核心线程数则加入等待队列.如果队列已满则无法加入,在线程数小于 maxinumPoolSize 指定的最大线程数前提下会创建新的线 程 来执行, 如果线程数大于 maxinumPoolSize 最大线程数则执行拒绝策略
• 无界任务队列,由 LinkedBlockingQueue 对象实现,与有界队 列相比,除非系统资源耗尽,否则无界队列不存在任务入队失败的 情况. 当有新的任务时,在系统线程数小于 corePoolSize 核心线程 数则创建新的线程来执行任务;当线程池中线程数量大于corePoolSize 核心线程数则把任务加入阻塞队列
• 优先任务队列是通过 PriorityBlockingQueue 实现的,是带有任务优先级的 队列 , 是一个特殊的无界队列 . 不管是ArrayBlockingQueue 队列还是 LinkedBlockingQueue 队列都是按照先进先出算法处理任务的.在 PriorityBlockingQueue 队列中可以根据任务优先级顺序先后执行.