java.util.concurrent.Executor理解

    相信搞java的都接触过java.util.concurrent.Executor，它的子类为ThreadPoolExecutor，在多线程方面这个接口能方便的构建一个线程池，调用此接口子类下的execute(Thread thread)便能将一个线程任务添加到此线程池中，由它统一管理你的线程调度及执行

 

    首先理解下它的几个重要参数：

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

corePoolSize：核心工作线程数

maximumPoolSize：最大工作线程数

keepAliveTime：线程池维护线程所允许的空闲时间

unit：线程池维护线程所允许的空闲时间的单位

workQueue：线程等待队列

threadFactory：构造线程的Factory

 

在这里要区分一下工作线程和任务线程，任务线程是我们实现Runnable接口或者继承Thread的来满足我们任务的线程，比如一个从网络下载图片的线程。工作线程则是ThreadPoolExecutor用于调度及管理来执行任务线程的线程。理解了这点后，我们来看一下ThreadPoolExecutor是如何创建和管理工作线程的。

(1)任务线程数<corePoolSize,则新创建一个工作线程去执行线程任务。

(2)corePoolSize+workQueue的大小>任务线程数>corePoolSize，将任务线程天骄等待队列workQueue中，此时不创建新的工作线程。

(3)maximumPoolSize+workQueue<任务线程数>corePoolSize+workQueue的大小，创建新的工作线程，直到产生maximumPoolSize+workQueue个工作线程。

(4)任务线程数>maximumPoolSize+workQueue，抛出RejectedExecutionException异常。

下面我们以一段代码来验证，先看任务线程，自己定义的一个MyTask类，代码如下：

public class MyTask implements Runnable{
	private int count = 0;
	
	public MyTask(int count){
		this.count = count;
	}
	
	public MyTask(){
		
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(1000);//模拟线程执行时间
			System.out.println("--count="+count+"  is excute  &  current thread name="+Thread.currentThread().getName());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

 接着构造一个ThreadPoolExecutor，代码如下

public class Test {
	private static int CORE_POOL_SIZE = 3;
	private static int MAXIMUM_POOL_SIZE = 128;
	private static final int KEEP_ALIVE = 1;

	private static final ThreadFactory sThreadFactory = new ThreadFactory() {
		private final AtomicInteger mCount = new AtomicInteger(1);

		public Thread newThread(Runnable r) {
			return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
		}
	};

	private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(
			10);

	public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
			CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS,
			sPoolWorkQueue, sThreadFactory);

	public static void main(String[] args) {
		for (int i = 0; i < 13; i++) {
			try {
				THREAD_POOL_EXECUTOR.execute(new MyTask(i));

			} catch (Exception e) {
				e.printStackTrace();

			}
		}

	}
}

在这里创建了一个核心工作线程(CORE_POOL_SIZE)为3，等带队列(sPoolWorkQueue)为10，最大工作线程(MAXIMUM_POOL_SIZE)为128的ThreadPoolExecutor，然后任务线程数为13个，刚好满足上述条件(2)，那么将不会创建核心工作线程，执行结果见图

 然后我们将i=13改成大于13且小于128+10=138的数字，此时条件满足上述(3)情形，我改为i<20，运行结果见图：

 我们看到核心工作线程增加了7个，由原来的3个增加到10个，刚好等待队列+核心工作线程为13，我的任务线程数为20，所以重新创建了7个工作线程。

接着我们把i设置成大于138的值，这是条件满足(4)，我这里设置为i<139，运行结果见图：

 多了一个任务线程，则抛出了异常。