Java开发笔记（一百零四）普通线程池的运用

前面介绍了线程的基本用法，以及多线程并发的问题处理，但实际开发中往往存在许多性质相似的任务，比如批量发送消息、批量下载文件、批量进行交易等等。这些同类任务的处理流程一致，不存在资源共享问题，相互之间也不需要通信交互，总之每个任务都可以看作是单独的事务，仿佛流水线上的原材料经过一系列步骤加工之后变为成品。可要是开启分线程的话，得对每项任务都分别创建新线程并予以启动，且不说如何的费时费力，单说这批量操作有多少任务就要开启多少分线程，系统的有限资源禁不起这么多的线程同时过来折腾。
就像工厂里的流水线，每条流水线的生产速度是有限的，一下子涌来大量原材料，一条流水线也消化不了，得多开几条流水线才行。但是流水线也不能想开就开，毕竟每开一条流水线都要占用工厂地盘，而且流水线开多了的话，后续没有这么多原材料的时候，岂不是造成资源浪费？到时又得关闭多余的流水线，纯属人傻钱多瞎折腾。所以呢，合理的做法应当是先开少数几条流水线，倘若有大批来料需要加工，再多开几条流水线，而且这些流水线要进行统一调度管理，新加的原料得放到空闲的流水线上加工，而不是再开新的流水线，这样才能在最大程度上节约生产资源、提高工作效率。
Java体系之中，若将线程比作流水线的话，好几个常驻的运行线程便组成了批量处理的工厂，那么工厂里面统一管理这些流水线的调度中心则被称为“线程池”。线程池封装了线程的创建、启动、关闭等操作，以及系统的资源分配与线程调度；它还支持任务的添加和移除功能，使得程序员可以专心编写任务代码的业务逻辑，不必操心线程怎么跑这些细枝末节。Java提供的线程池工具最常用的是ExecutorService及其派生类ThreadPoolExecutor，它支持以下四种线程池类型：
1、只有一个线程的线程池，该线程池由Executors类的newSingleThreadExecutor方法创建而来。它的创建代码示例如下：

		// 创建一个只有一个线程的线程池
		ExecutorService pool = (ExecutorService) Executors.newSingleThreadExecutor();

2、拥有固定数量线程的线程池，该线程池由Executors类的newFixedThreadPool方法创建而来，方法参数即为线程数量。它的创建代码示例如下：

		// 创建一个线程数量为3的线程池
		ExecutorService pool = (ExecutorService) Executors.newFixedThreadPool(3);

3、拥有无限数量线程的线程池，该线程池由Executors类的newCachedThreadPool方法创建而来。它的创建代码示例如下：

		// 创建一个不限制线程数量的线程池
		ExecutorService pool = (ExecutorService) Executors.newCachedThreadPool();

4、线程数量允许变化的线程池，该线程池需要调用ThreadPoolExecutor的构造方法来创建，构造方法的输入参数按顺序说明如下：
第一个参数是个整型数，名叫corePoolSize，它指定了线程池的最小线程个数。
第二个参数也是个整型数，名叫maximumPoolSize，它指定了线程池的最大线程个数。
第三个参数是个长整数，名叫keepAliveTime，它指定了每个线程保持活跃的时长，如果某个线程的空闲时间超过这个时长，则该线程会结束运行，直到线程池中的线程总数等于corePoolSize为止。
第四个参数为TimeUnit类型，名叫unit，它指定了第三个参数的时间单位，比如TimeUnit.SECONDS表示时间单位是秒。
第五个参数为BlockingQueue类型，它指定了待执行线程所处的等待队列。
第四种线程池（自定义线程池）的创建代码示例如下：

		// 创建一个自定义规格的线程池（最小线程个数为2，最大线程个数为5，每个线程保持活跃的时长为60，时长单位秒，等待队列大小为19）
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				2, 5, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(19));

创建好了线程池之后，即可调用线程池对象的execute方法将指定任务加入线程池。需要注意的是，execute方法并不一定立刻执行指定任务，只有当线程池中存在空闲线程或者允许创建新线程之时，才会马上执行任务；否则会将该任务放到等待队列，然后按照排队顺序在方便的时候再一个一个执行队列中的任务。除了execute方法方法，ExecutorService还提供了若干查询与调度方法，这些方法的用途简介如下：
getCorePoolSize：获取核心的线程个数（即线程池的最小线程个数）。
getMaximumPoolSize：获取最大的线程个数（即线程池的最大线程个数）。
getPoolSize：获取线程池的当前大小（即线程池的当前线程个数）。
getTaskCount：获取所有的任务个数。
getActiveCount：获取活跃的线程个数。
getCompletedTaskCount：获取已完成的任务个数。
remove：从等待队列中移除指定任务。
shutdown：关闭线程池。关闭之后不能再往线程池中添加任务，不过要等已添加的任务执行完，才最终关掉线程池。
shutdownNow：立即关闭线程池。之后同样不能再往线程池中添加任务，同时会给已添加的任务发送中断信号，直到所有任务都退出才最终关掉线程池。
isShutdown：判断线程池是否已经关闭。

接下来做个实验，看看几种线程池是否符合预期的运行方式。实验开始前先定义一个操作任务，很简单，仅仅打印本次的操作日志，包括操作时间、操作线程、操作描述等信息。操作任务的代码例子如下所示：

	// 定义一个操作任务
	private static class Operation implements Runnable {
		private String name; // 任务名称
		private int index; // 任务序号
		public Operation(String name, int index) {
			this.name = name;
			this.index = index;
		}

		@Override
		public void run() {
			// 以下打印操作日志，包括操作时间、操作线程、操作描述等信息
			String desc = String.format("%s执行到了第%d个任务", name, index+1);
			PrintUtils.print(Thread.currentThread().getName(), desc);
		}
	};

然后分别命令每种线程池各自启动十个上述的操作任务。首先是单线程的线程池，它的实验代码示例如下：

	// 测试单线程的线程池
	private static void testSinglePool() {
		// 创建一个只有一个线程的线程池
		ExecutorService pool = (ExecutorService) Executors.newSingleThreadExecutor();
		for (int i=0; i<10; i++) { // 循环启动10个任务
			// 创建一个操作任务
			Operation operation = new Operation("单线程的线程池", i);
			pool.execute(operation); // 命令线程池执行该任务
		}
		pool.shutdown(); // 关闭线程池
	}

运行以上的实验代码，观察到如下的线程池日志：

22:22:43.959 pool-1-thread-1 单线程的线程池执行到了第1个任务
22:22:43.960 pool-1-thread-1 单线程的线程池执行到了第2个任务
22:22:43.961 pool-1-thread-1 单线程的线程池执行到了第3个任务
22:22:43.961 pool-1-thread-1 单线程的线程池执行到了第4个任务
22:22:43.962 pool-1-thread-1 单线程的线程池执行到了第5个任务
22:22:43.962 pool-1-thread-1 单线程的线程池执行到了第6个任务
22:22:43.962 pool-1-thread-1 单线程的线程池执行到了第7个任务
22:22:43.963 pool-1-thread-1 单线程的线程池执行到了第8个任务
22:22:43.963 pool-1-thread-1 单线程的线程池执行到了第9个任务
22:22:43.963 pool-1-thread-1 单线程的线程池执行到了第10个任务

由日志可见，单线程的线程池始终只有一个名叫pool-1-thread-1的线程在执行任务。

继续测试固定数量的线程池，它的实验代码示例如下：

	// 测试固定数量的线程池
	private static void testFixedPool() {
		// 创建一个线程数量为3的线程池
		ExecutorService pool = (ExecutorService) Executors.newFixedThreadPool(3);
		for (int i=0; i<10; i++) { // 循环启动10个任务
			// 创建一个操作任务
			Operation operation = new Operation("固定数量的线程池", i);
			pool.execute(operation); // 命令线程池执行该任务
		}
		pool.shutdown(); // 关闭线程池
	}

运行以上的实验代码，观察到如下的线程池日志：

22:23:15.141 pool-1-thread-1 固定数量的线程池执行到了第1个任务
22:23:15.141 pool-1-thread-2 固定数量的线程池执行到了第2个任务
22:23:15.141 pool-1-thread-3 固定数量的线程池执行到了第3个任务
22:23:15.142 pool-1-thread-1 固定数量的线程池执行到了第4个任务
22:23:15.142 pool-1-thread-3 固定数量的线程池执行到了第5个任务
22:23:15.142 pool-1-thread-2 固定数量的线程池执行到了第6个任务
22:23:15.142 pool-1-thread-3 固定数量的线程池执行到了第7个任务
22:23:15.143 pool-1-thread-2 固定数量的线程池执行到了第8个任务
22:23:15.143 pool-1-thread-1 固定数量的线程池执行到了第9个任务
22:23:15.143 pool-1-thread-2 固定数量的线程池执行到了第10个任务

由日志可见，固定数量的线程池一共开启了三个线程去执行任务。

再来测试无限数量的线程池，它的实验代码示例如下：

	// 测试无限数量的线程池
	private static void testUnlimitPool() {
		// 创建一个不限制线程数量的线程池
		ExecutorService pool = (ExecutorService) Executors.newCachedThreadPool();
		for (int i=0; i<10; i++) { // 循环启动10个任务
			// 创建一个操作任务
			Operation operation = new Operation("无限数量的线程池", i);
			pool.execute(operation); // 命令线程池执行该任务
		}
		pool.shutdown(); // 关闭线程池
	}

运行以上的实验代码，观察到如下的线程池日志：

22:25:52.344 pool-1-thread-6 无限数量的线程池执行到了第6个任务
22:25:52.344 pool-1-thread-3 无限数量的线程池执行到了第3个任务
22:25:52.344 pool-1-thread-5 无限数量的线程池执行到了第5个任务
22:25:52.344 pool-1-thread-8 无限数量的线程池执行到了第8个任务
22:25:52.344 pool-1-thread-7 无限数量的线程池执行到了第7个任务
22:25:52.344 pool-1-thread-4 无限数量的线程池执行到了第4个任务
22:25:52.344 pool-1-thread-1 无限数量的线程池执行到了第1个任务
22:25:52.344 pool-1-thread-9 无限数量的线程池执行到了第9个任务
22:25:52.344 pool-1-thread-2 无限数量的线程池执行到了第2个任务
22:25:52.344 pool-1-thread-10 无限数量的线程池执行到了第10个任务

由日志可见，无限数量的线程池真的没限制线程个数，有多少任务就启动多少线程，虽然跑得很快但是系统压力也大。

最后是自定义的线程池，它的实验代码示例如下：

	// 测试自定义的线程池
	private static void testCustomPool() {
		// 创建一个自定义规格的线程池（最小线程个数为2，最大线程个数为5，每个线程保持活跃的时长为60，时长单位秒，等待队列大小为19）
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				2, 5, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(19));
		for (int i=0; i<10; i++) { // 循环启动10个任务
			// 创建一个操作任务
			Operation operation = new Operation("自定义的线程池", i);
			pool.execute(operation); // 命令线程池执行该任务
		}
		pool.shutdown(); // 关闭线程池
	}

运行以上的实验代码，观察到如下的线程池日志：

22:28:46.337 pool-1-thread-1 自定义的线程池执行到了第1个任务
22:28:46.337 pool-1-thread-2 自定义的线程池执行到了第2个任务
22:28:46.338 pool-1-thread-2 自定义的线程池执行到了第4个任务
22:28:46.338 pool-1-thread-1 自定义的线程池执行到了第3个任务
22:28:46.339 pool-1-thread-2 自定义的线程池执行到了第5个任务
22:28:46.339 pool-1-thread-1 自定义的线程池执行到了第6个任务
22:28:46.339 pool-1-thread-2 自定义的线程池执行到了第7个任务
22:28:46.339 pool-1-thread-1 自定义的线程池执行到了第8个任务
22:28:46.340 pool-1-thread-2 自定义的线程池执行到了第9个任务
22:28:46.340 pool-1-thread-1 自定义的线程池执行到了第10个任务

由日志可见，自定义的线程池通常仅保持最小量的线程数，只有短时间涌入大批任务的时候，才会把线程数加码到最大数量。

更多Java技术文章参见《Java开发笔记（序）章节目录》