java.util.concurrent包探秘(一)之Executors

1. 类简介

  Executors类可以看做一个“工具类”。援引JDK1.6 API中的介绍：

  此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。此类支持以下各种方法：

• 创建并返回设置有常用配置字符串的 ExecutorService 的方法。
• 创建并返回设置有常用配置字符串的 ScheduledExecutorService 的方法。
• 创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。
• 创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。
• 创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中。

    通过这个类能够获得多种线程池的实例，例如可以调用newSingleThreadExecutor()获得单线程的ExecutorService，调 用newFixedThreadPool()获得固定大小线程池的ExecutorService，等等。拿到ExecutorService可以做的事情就比 较多了，最简单的是用它来执行Runnable对象，也可以执行一些实现了Callable<T>的对象。用Thread的start()方 法没有返回值，如果该线程执行的方法有返回值那用ExecutorService就再好不过了，可以选择submit()、invokeAll()或者 invokeAny()，根据具体情况选择合适的方法即可。

 

2. 主要方法说明

newFixedThreadPool（固定大小线程池）
创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程（只有要请求的过来，就会在一个队列里等待执行）。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。

newCachedThreadPool（无界线程池，可以进行自动线程回收）
创 建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调 用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已 有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。注意，可以使用 ThreadPoolExecutor 构造方法创建具 有类似属性但细节不同（例如超时参数）的线程池。

newSingleThreadExecutor（单个后台线程）
创 建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线 程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效 的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

这些方法返回的都是ExecutorService对象，这个对象可以理解为就是一个线程池。
这个线程池的功能还是比较完善的。可以提交任务submit()可以结束线程池shutdown()。

注意：shutdown()方法并不是终止线程的执行，而是禁止在这个Executor中添加新的任务。

 

3. Executors主要方法介绍

在对Executors主要方法进行介绍之前，我们有必要对其中的几个接口进行简单了解一下。它们分别为Executor、ExecutorService和ScheduledExecutorService

 

Executor此接口提供一种将任务提交与每个任务将如何运行的机制（包括线程使用的细节、调度等）分离开来的方法。此接口只有一个execute(Runnable command)方法

 

ExecutorService

ExecuteService继承了Executor，其中的submit方法对Executor的execute方法进行了扩展。

 

ScheduledExecutorService

ScheduledExecutorService继承了ExecuteService，可安排在给定的延迟后运行或定期执行的命令

 

==============接下来，我们结合示例来看一下以上列出的几个方法的使用====================

以newFixedThreadPool为例，其他几个雷同。

 

package com.gw.concurrent;

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 *@author zcc
 *@date  2013-7-24
 *@description 
 *@version 1.0.0
 */
public class TestNewFixedThreadPool
{

	public static void main(String[] args) throws IOException,InterruptedException
	{
		ExecutorService service = Executors.newFixedThreadPool(2);
		for(int i = 0; i < 4; i++)
		{
			Runnable run = new Runnable() {
				
				public void run()
				{
					for(int j = 0; j < 10; j++)
					{
						System.out.println(j);
					}
				}
			};
			service.execute(run);
		}
		service.shutdown();
		service.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
		System.out.println("all thread complete");
	}
}

     newFixedThreadPool生成一个固定的线程池，顾名思义，线程池的线程是不会释放的，即使它是Idle。这就会产生性能问题，比如如果线程池的大小为200，当全部使用完毕后，所有的线程会继续留在池中，相应的内存和线程切换（while(true)+sleep循环）都会增加。如果要避免这个问题，就必须直接使用ThreadPoolExecutor()来构造。可以像Tomcat的线程池一样设置“最大线程数”、“最小线程数”和“空闲线程keepAlive的时间”。

   

public class TestThreadPoolExecutor 
{

	public static void main(String[] args) 
	{
		BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
		ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.DAYS, queue);

		for (int i = 0; i < 20; i++) 
		{
			final int index = i;
			executor.execute(new Runnable() {
				public void run() 
				{
					try 
					{
						Thread.sleep(4000);
					} 
					catch (InterruptedException e) 
					{
						e.printStackTrace();
					}
					System.out.println(String.format("thread %d finished", index));
				}
			});
		}
		executor.shutdown();
	}
}