ExecutorService和Executors

ExecutorService 是一个线程池的实现
ExecutorService exec = Executors.newCachedThreadPool();
ExecutorService exec1 = Executors.newFixedThreadPool(cupNum * THREAD_POOL_SIZE);  // 根据CPU的数量来决定最大的线程数  

ExecutorService exec2 = Executors.newSingleThreadExecutor(); 

区别： 
1、Executors.newCachedThreadPool()
exec每遇到一个Runnable的对象，就会创建一个线程来处理任务。
现在假设遇到到第4个任务时，之前用于处理第一个任务的线程已经执行完成任务了，
那么不会创建新的线程来处理任务，而是使用之前处理第一个任务的线程来处理这第4个任务。
接着如果遇到第5个任务时，前面那些任务都还没有执行完，那么就会又新创建线程来执行第5个任务。
否则，使用之前执行完任务的线程来处理新的任务。
ExecutorService exec = Executors.newCachedThreadPool();
for(int i = 0; i < 10; i++) {   
        exec.execute(et.new RunnableTest());
        }
        exec.shutdown(); 

结果：10个任务开启了5个线程
executorRunnable is execute , name = pool-1-thread-1 , id = 10
executorRunnable is execute , name = pool-1-thread-4 , id = 13
executorRunnable is execute , name = pool-1-thread-2 , id = 11
executorRunnable is execute , name = pool-1-thread-1 , id = 10
executorRunnable is execute , name = pool-1-thread-4 , id = 13
executorRunnable is execute , name = pool-1-thread-2 , id = 11
executorRunnable is execute , name = pool-1-thread-4 , id = 13
executorRunnable is execute , name = pool-1-thread-5 , id = 14
executorRunnable is execute , name = pool-1-thread-2 , id = 11
executorRunnable is execute , name = pool-1-thread-3 , id = 12




2、Executors.newFixedThreadPool（4）
FixedThreadPool模式会使用一个优先固定数目的线程来处理若干数目的任务。
规定数目的线程处理所有任务，一旦有线程处理完了任务就会被用来处理新的任务(如果有的话)。
这种模式与上面的CachedThreadPool是不同的，CachedThreadPool模式下处理一定数量的任务的线程数目是不确定的。
而FixedThreadPool模式下最多 的线程数目是一定的。
ExecutorService exec1 = Executors.newFixedThreadPool(4);  // 根据CPU的数量来决定最大的线程数          
        for(int i = 0; i < 10; i++) {   
        exec1.execute(et.new RunnableTest());
        }
        exec1.shutdown();


结果：10个任务用了4个线程去执行，因为我指定了只开启4个线程
executorRunnable is execute , name = pool-2-thread-2 , id = 11
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-3 , id = 12
executorRunnable is execute , name = pool-2-thread-3 , id = 12
executorRunnable is execute , name = pool-2-thread-3 , id = 12
executorRunnable is execute , name = pool-2-thread-3 , id = 12
executorRunnable is execute , name = pool-2-thread-3 , id = 12
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-2 , id = 11
executorRunnable is execute , name = pool-2-thread-4 , id = 13


3、Executors.newSingleThreadExecutor();
SingleThreadExecutor模式只会创建一个线程。它和FixedThreadPool比较类似，不过线程数是一个。
如果多个任务被提交给SingleThreadExecutor的话，那么这些任务会被保存在一个队列中，并且会按照任务提交的顺序，一个先执行完成再执行另外一个线程.
SingleThreadExecutor模式可以保证只有一个任务会被执行。
这种特点可以被用来处理共享资源的问题而不需要考虑同步的问题。

1. ExecutorService exec2 = Executors.newSingleThreadExecutor();  
2.         for(int i = 0; i < 10; i++) {     
3.             exec2.execute(et.new RunnableTest());  
4.         }  
5.         exec2.shutdown();  

结果：10个任务用一个线程顺序执行
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10
executorRunnable is execute , name = pool-2-thread-1 , id = 10

<span style="font-size:14px;">package com.java.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorTest {

	private final static int THREAD_POOL_SIZE = 1;
	/**
	 * @param args
	 */
	public static void main(String[] args) {

		int cupNum = Runtime.getRuntime().availableProcessors();  // 获得CPU的个数
		
		System.out.println("cupNum = " + cupNum);
		
		ExecutorService exec = Executors.newCachedThreadPool();   
		ExecutorTest et = new ExecutorTest();
		/*采用CachedThreadPool模式，
		 * exec每遇到一个RunnableTest的对象(Task)，就会创建一个线程来处理任务。
		 * 现在假设遇到到第4个任务时，之前用于处理第一个任务的线程已经执行完成任务了，
		 * 那么不会创建新的线程来处理任务，而是使用之前处理第一个任务的线程来处理这第4个任务。
		 * 接着如果遇到第5个任务时，前面那些任务都还没有执行完，那么就会又新创建线程来执行第5个任务。
		 * 否则，使用之前执行完任务的线程来处理新的任务。*/
        for(int i = 0; i < 10; i++) {   
        	exec.execute(et.new RunnableTest());
        }
        exec.shutdown();   // 表示不在接收新的任务

        //FixedThreadPool
        /*FixedThreadPool模式会使用一个优先固定数目的线程来处理若干数目的任务。
         * 规定数目的线程处理所有任务，一旦有线程处理完了任务就会被用来处理新的任务(如果有的话)。
         * 这种模式与上面的CachedThreadPool是不同的，CachedThreadPool模式下处理一定数量的任务的线程数目是不确定的。
         * 而FixedThreadPool模式下最多 的线程数目是一定的。*/
        ExecutorService exec1 = Executors.newFixedThreadPool(cupNum * THREAD_POOL_SIZE);  // 根据CPU的数量来决定最大的线程数          
        for(int i = 0; i < 10; i++) {   
        	exec1.execute(et.new RunnableTest());
        }
        exec1.shutdown();
        
        // SingleThreadExecutor
        /*SingleThreadExecutor模式只会创建一个线程。它和FixedThreadPool比较类似，不过线程数是一个。
         * 如果多个任务被提交给SingleThreadExecutor的话，那么这些任务会被保存在一个队列中，并且会按照任务提交的顺序，一个先执行完成再执行另外一个线程.
         * SingleThreadExecutor模式可以保证只有一个任务会被执行。
         * 这种特点可以被用来处理共享资源的问题而不需要考虑同步的问题。*/
        ExecutorService exec2 = Executors.newSingleThreadExecutor();
        for(int i = 0; i < 10; i++) {   
        	exec2.execute(et.new RunnableTest());
        }
        exec2.shutdown();
	}

	
	class RunnableTest implements Runnable{

		public void run() {
			System.out.println("executorRunnable is execute , name = " + Thread.currentThread().getName() + " , id = " + Thread.currentThread().getId());
		}
	};
}
</span>