详解Executors创建3种类型的ThreadPoolExecutor线程池

最近在学习比较基础的并发编程，做了一下笔记顺便写写到博客这里。

1、newFixedThreadPool()

创建固定长度的线程池，每次提交任务创建一个线程，直到达到线程池的最大数量，线程池的大小不会变化。 特点是可以重用固定数量线程的线程池。

它的构造源码如下：

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

• FixedThreadPool的corePoolSize和maxiumPoolSize都被设置为创建FixedThreadPool时指定的参数nThreads。
• 0L则表示当线程池中的线程数量操作核心线程的数量时，多余的线程将被立即停止
• 最后一个参数表示FixedThreadPool使用了无界队列LinkedBlockingQueue作为线程池的做工队列，由于是无界的，当线程池的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池的线程数量不会超过corePoolSize，同时maxiumPoolSize也就变成了一个无效的参数，并且运行中的线程池并不会拒绝任务。

例子：

Task：因为线程池执行的任务必须实现Runnable或者Callbale接口，就是可执行的。下面的Task就实现了Runnable接口，有id和name两个属性，然后重写run方法，打印哪个线程执行了。

public class Task implements Runnable{
	private int id;
	private String name;
	Random dom = new Random();
	
	@Override
	public void run() {//实现Runnable接口重写run方法
		try {
			Thread.sleep(dom.nextInt(2000));  //随机休眠，让执行效果明显一点
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(name+"：正在被线程"+Thread.currentThread().getName()+"执行");
	}
	
	
	public Task(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	
	
	public int getId() {
		return id;
	}


	public void setId(int id) {
		this.id = id;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}

}

测试代码：

public static void main(String[] args) throws InterruptedException {
		ExecutorService pool = Executors.newFixedThreadPool(2);
		Task t1 = new Task(1,"任务1");
		Task t2 = new Task(2,"任务2");
		Task t3 = new Task(3,"任务3");
		Task t4 = new Task(4,"任务4");
		Task t5 = new Task(5,"任务5");
		Task t6 = new Task(6,"任务6");
		Task t7 = new Task(7,"任务7");
		
		pool.execute(t1);
		pool.execute(t2);
		pool.execute(t3);
		pool.execute(t4);
		pool.execute(t5);
		pool.execute(t6);
		pool.execute(t7);
		
		pool.shutdown();
	}

执行结果：只有两个线程执行任务

任务2：正在被线程pool-1-thread-2执行
任务1：正在被线程pool-1-thread-1执行
任务3：正在被线程pool-1-thread-2执行
任务4：正在被线程pool-1-thread-1执行
任务6：正在被线程pool-1-thread-1执行
任务5：正在被线程pool-1-thread-2执行
任务7：正在被线程pool-1-thread-1执行

2、newSingleThreadExecutor()

SingleThreadExecutor是使用单个worker线程的Executor。 特点是使用单个工作线程执行任务 。它的构造源码如下：

public   static  ExecutorService newSingleThreadExecutor() {          return   new  FinalizableDelegatedExecutorService             ( new  ThreadPoolExecutor( 1 ,  1 ,                                     0L, TimeUnit.MILLISECONDS,                                      new  LinkedBlockingQueue<Runnable>())); }

　　

SingleThreadExecutor的corePoolSize和maxiumPoolSize都被设置1。

其他参数均与FixedThreadPool相同，其运行图如下：

 

执行过程如下：

1.如果当前工作中的线程数量少于corePool的数量，就创建一个新的线程来执行任务。

2.当线程池的工作中的线程数量达到了corePool，则将任务加入LinkedBlockingQueue。

3.线程执行完1中的任务后会从队列中去任务。

注意：由于在线程池中只有一个工作线程，所以任务可以按照添加顺序执行。

例子：

Task:还是使用上面的

测试代码：

public static void main(String[] args) throws InterruptedException {
		ExecutorService pool = Executors.newSingleThreadExecutor();
		Task t1 = new Task(1,"任务1");
		Task t2 = new Task(2,"任务2");
		Task t3 = new Task(3,"任务3");
		Task t4 = new Task(4,"任务4");
		Task t5 = new Task(5,"任务5");
		Task t6 = new Task(6,"任务6");
		Task t7 = new Task(7,"任务7");
		
		pool.execute(t1);
		pool.execute(t2);
		pool.execute(t3);
		pool.execute(t4);
		pool.execute(t5);
		pool.execute(t6);
		pool.execute(t7);
		
		pool.shutdown();
	}

执行结果：只有一个线程执行任务

任务1：正在被线程pool-1-thread-1执行
任务2：正在被线程pool-1-thread-1执行
任务3：正在被线程pool-1-thread-1执行
任务4：正在被线程pool-1-thread-1执行
任务5：正在被线程pool-1-thread-1执行
任务6：正在被线程pool-1-thread-1执行
任务7：正在被线程pool-1-thread-1执行

3、newCachedThreadPool()

 CachedThreadPool是一个”无限“容量的线程池，它会根据需要创建新线程。 特点是可以根据需要来创建新的线程执行任务，没有特定的corePool 。下面是它的构造方法：

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

　　

CachedThreadPool的corePoolSize被设置为0，即corePool为空；maximumPoolSize被设置为Integer.MAX_VALUE，即maximum是无界的。这里keepAliveTime设置为60秒，意味着空闲的线程最多可以等待任务60秒，否则将被回收。

 

CachedThreadPool使用没有容量的SynchronousQueue作为主线程池的工作队列，它是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作。这意味着，如果主线程提交任务的速度高于线程池中处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU资源。其运行图如下：

 

执行过程如下：

1.首先执行SynchronousQueue.offer(Runnable task)。如果在当前的线程池中有空闲的线程正在执行SynchronousQueue.poll()，那么主线程执行的offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行。，execute()方法执行成功，否则执行步骤2

2.当线程池为空(初始maximumPool为空)或没有空闲线程时，配对失败，将没有线程执行SynchronousQueue.poll操作。这种情况下，线程池会创建一个新的线程执行任务。

3.在创建完新的线程以后，将会执行poll操作。当步骤2的线程执行完成后，将等待60秒，如果此时主线程提交了一个新任务，那么这个空闲线程将执行新任务，否则被回收。因此长时间不提交任务的CachedThreadPool不会占用系统资源。

SynchronousQueue是一个不存储元素阻塞队列，每次要进行offer操作时必须等待poll操作，否则不能继续添加元素。

例子：

Task：还是上面的一样

测试代码：

public static void main(String[] args) throws InterruptedException {
		ExecutorService pool = Executors.newCachedThreadPool();
		Task t1 = new Task(1,"任务1");
		Task t2 = new Task(2,"任务2");
		Task t3 = new Task(3,"任务3");
		Task t4 = new Task(4,"任务4");
		Task t5 = new Task(5,"任务5");
		Task t6 = new Task(6,"任务6");
		Task t7 = new Task(7,"任务7");
		
		pool.execute(t1);
		pool.execute(t2);
		pool.execute(t3);
		pool.execute(t4);
		Thread.sleep(2000);  //主线程休眠两秒，为了测试CachedThreadPool创建的线程会空闲60s后才回收
		pool.execute(t5);
		pool.execute(t6);
		pool.execute(t7);
		
		pool.shutdown();
	}

执行结果：可以看到，线程234确实执行完旧任务后又执行新任务

任务1：正在被线程pool-1-thread-1执行
任务2：正在被线程pool-1-thread-2执行
任务3：正在被线程pool-1-thread-3执行
任务4：正在被线程pool-1-thread-4执行
任务5：正在被线程pool-1-thread-4执行
任务6：正在被线程pool-1-thread-3执行
任务7：正在被线程pool-1-thread-2执行