简介线程池使用

下面线程池的相关类或者接口的整体结构，对于方法只列出了部分，详细的介绍可以参考下API文档。（类图整体画的有点丑，空间就这么大，理解下）。



线程池是用来管理线程的，也许一般的时候，我们开个线程执行完就可以了，但当大量的线程开始执行的时候，我们就需要考虑资源和性能等问题了，线程池就是起这方面作用的。

合理的使用线程池，我们能通过重复利用已创建的线程降低线程创建和销毁造成的消耗，任务可以不需要等到线程创建就能立即执行来提高响应速度，对线程的统一分配，调优和监控来提高可管理性。

线程池的创建，我们一般有两种办法：

1.自己动手实现Executor，常见的是新建ThreadPoolExecutor对象来管理Runnable，然后自己配置相关的参数。

2.使用JDK提供的工厂方法，快捷的建立线程池（也是推荐的线程池方法）。

ThreadPoolExecutor

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

corePoolSize:线程池中常驻的最少线程数量。

maximumPoolSize:线程池中最大允许的线程数量。

keepAliveTime:当线程的数量大于核心线程数时，这是空闲线程等待新任务结束的最大时间。

unit:给定单元粒度的时间段。

workQueue:保持任务到执行前的队列。

threadFactory:当创建新线程时使用的工厂。

handler:当执行因为到达线程边界或队列容量而受阻时使用。

示例：

public class TestMain {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BlockingQueue queue = new LinkedBlockingDeque();

		ThreadPoolExecutor ex = new ThreadPoolExecutor(1, 2, 1, TimeUnit.DAYS,
				queue);

		String s = "";
		for (int i = 0; i < 6; i++) {
			ex.execute(new TestTask(s + i));
		}
	}
}

class TestTask implements Runnable {
	private String s;

	public TestTask(String s) {
		this.s = s;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(s);
	}

}

Executors

static ExecutorService newCachedThreadPool() 
          创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。 
static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) 
          创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。 
static ExecutorService newFixedThreadPool(int nThreads) 
          创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。 
static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) 
          创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，在需要时使用提供的 ThreadFactory 创建新线程。 
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 
          创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。 
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) 
          创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。 
static ExecutorService newSingleThreadExecutor() 
          创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。 
static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) 
          创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程，并在需要时使用提供的 ThreadFactory 创建新线程。 
static ScheduledExecutorService newSingleThreadScheduledExecutor() 
          创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。 
static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) 
          创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行

提供了众多的静态方法，直接的创建常见的线程池，非常方便。

public class TestMain {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//工厂方法
		ExecutorService service = Executors.newCachedThreadPool();

		String s = "";
		for (int i = 0; i < 6; i++) {
			service.execute(new TestTask(s + i));
		}
	}
}

class TestTask implements Runnable {
	private String s;

	public TestTask(String s) {
		this.s = s;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(s);
	}

}

newCachedThreadPool():
创建一个可缓存的线程池，可以重用以前构造的线程。对于执行很多短期异步任务的程序而言，可以提高程序的性能。

有以下特点：

1.工作线程的创建数量几乎没有限制，如果线程可用，就重用以前构造的。

2.工作线程空闲了指定时间（60s），就会自动终止。当遇到新提交的任务，会重新创建一个工作线程，添加到池中。

newFixedThreadPool():

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行线程。

每当提交一个任务就会创建一个工作线程，如果工作线程数量达到线程池初始化的最大数，那么任务就存入到池队列中。但在线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

newScheduleThreadPool():

创建一个可以安排在给定延迟后运行命令或定期执行的线程池。

ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

定是或者周期性运行，类似Timer。

newSingleThreadExecutor():

创建唯一的工作线程执行任务，如果线程异常结束，会有另外一个取代，保证顺序执行。

可以保证顺序的执行各个任务，同一时间只有一个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

newSingleThreadScheduledExecutor():

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

排队的3种通用策略：

1.直接提交

工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

2.无界队列

使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超corePoolSize。（因此，maximumPoolSize的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

3.有界队列

当使用有限的 maximumPoolSizes时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。