Java ThreadPoolExecutor 学习笔记（一）

写这篇文章主要还是为了强迫自己把学习Java源代码的一些要点记录下来。

构造函数：
[b]ThreadPoolExecutor[/b](
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)

参数含义：
[b]corePoolSize[/b] 线程池里面保存的最多可以闲置的线程数量。[b]allowCoreThreadTimeOut[/b]被调用后，则没有线程能够在timeout后还保存在线程池里
[b]maximumPoolSize[/b] 线程池里面保存最多的线程数量
[b]keepAliveTime[/b]，[b]unit[/b] 当线程池里面保存的线程数量大于corePoolSize后，闲置的线程等待最大指定的时间（然后被关闭）
[b]workQueue[/b] 用来保存被提交的任务
[b]threadFactory[/b] 用来创建新线程的factory
[b]handler[/b] 当所有线程都在执行任务并且workQueue已经满了，handler处理新提交进来的任务

JDK 自带的 RejectedExecutionHandler 实现有4个：AbortPolicy, CallerRunsPolicy, DiscardOldestPolicy, DiscardPolicy。
[b]AbortPolicy[/b] 是默认策略直接 throw RejectedExecutionException
[b]CallerRunsPolicy[/b] 当Executor没有被关闭，则直接由提交任务的线程直接运行
[b]DiscardOldestPolicy[/b] 当Executor没有被关闭，从workQueue里面删除等待最久的一个任务，然后再调用execute
[b]DiscardPolicy[/b] 当前任务被直接抛弃


ThreadPoolExecutor 的 AtomicInteger ctl 属性很有意思，是一个32位的 AtomicInteger 。在最高3位存储了当前 ThreadPoolExecutor 的状态，后面29位用于存储当前线程的数量。所以在很多 ThreadPoolExecutor 的方法调用里面，CAS操作要求状态和线程的数量都是所期望的，才能进行后面的操作。

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); // 00000000000000000000000000000000
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY   = (1 << COUNT_BITS) - 1; // 00011111111111111111111111111111

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS; // 11100000000000000000000000000000
private static final int SHUTDOWN   =  0 << COUNT_BITS; // 00000000000000000000000000000000
private static final int STOP       =  1 << COUNT_BITS; // 00100000000000000000000000000000
private static final int TIDYING    =  2 << COUNT_BITS; // 01000000000000000000000000000000
private static final int TERMINATED =  3 << COUNT_BITS; // 01000000000000000000000000000000

// 获取当前的状态
private static int runStateOf(int c) {
	return c & ~CAPACITY;
}

// 获取当前的线程数量
private static int workerCountOf(int c) {
	return c & CAPACITY;
}

// 合并状态和线程数量
private static int ctlOf(int rs, int wc) {
	return rs | wc;
}

其他属性：

volatile RejectedExecutionHandler handler

BlockingQueue<Runnable> workQueue // 用来存储提交的任务。一般是使用 LinkedBlockingQueued

HashSet<Worker> workers // 工作线程抽象成了 Worker

long completedTaskCount // 完成任务的数量

ReentrantLock mainLock = new ReentrantLock() // 在需要访问 workers，completedTaskCount 时候需要先获取 mainLock。包括在添加 Worker，中断线程，关闭线程池等时候

Condition termination = mainLock.newCondition() // 用来等待线程池

volatile int corePoolSize // 核心线程的最大数量

volatile int maximumPoolSize // 所有线程的最大数量

volatile long keepAliveTime // 非核心线程的超时时间

volatile boolean allowCoreThreadTimeOut // 是否让核心线程也超时。默认为 false，即核心线程永远存活，直到关闭线程池。如果调用void allowCoreThreadTimeOut(boolean value)设置为 true, 即核心线程 idle 超过 keepAliveTime 时间以后，也会被关闭

volatile ThreadFactory threadFactory // 用来创建线程的工厂

[url=http://vampiredx.iteye.com/blog/2211153]Java ThreadPoolExecutor 学习笔记（二）[/url]
[url=http://vampiredx.iteye.com/blog/2211585]Java ThreadPoolExecutor 学习笔记（三）[/url]