AsyncTask 同步线程池构造

AsyncTask 初始化线程池

     // We want at least 2 threads and at most 4 threads in the core pool,
    // preferring to have 1 less than the CPU count to avoid saturating
    // the CPU with background work
    // 我们希望核心池中至少有2个线程和最多4个线程，最好是比CPU数少1个线程，以避免使CPU背景饱和
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;// 超出的最长等待时间(s)

    // 线程创建工厂
    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());
        }
    };

    // 此阻塞队列仅保持由 execute 方法提交的 Runnable 任务。
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    public static final Executor THREAD_POOL_EXECUTOR;// 并行化线程池引用

    // 使用 静态代码块 初始化 线程池
    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

SerialExecutor

将并行线程池，改成同步线程池

 // 将并行化线程池 转化为 串行化,实现机制类似递归调用
    private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            // 向双端队列中添加 Runnable()
            mTasks.offer(new Runnable() { 
                public void run() {
                    try {
                        r.run();// 编写 run 方法，此时并未执行
                    } finally {
                        scheduleNext();// 执行完一次，寻找下一次，并执行，直到双端队列内无数据
                    }
                }
            });
            if (mActive == null) { // 如果是第一次执行execute() 此时 mActive = null,执行
                scheduleNext();
            }
        }
        // 并行化线程池 执行 双端队列中的 Runnable()
        protected synchronized void scheduleNext() {
            if ( (mActive = mTasks.poll())  != null) { // 取出双端队列的末尾 Runnable() 
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }            
    }

ThreadPoolExecutor

java1.5提供的 java.util.concurrent 库方法

// ThreadPoolExecutor 的其一构造方法
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)

用给定的初始参数和默认被拒绝的执行处理程序创建新的 ThreadPoolExecutor。

参数：

corePoolSize - 池中所保存的线程数，包括空闲线程。
maximumPoolSize - 池中允许的最大线程数。
keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime 参数的时间单位。
workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。
threadFactory - 执行程序创建新线程时使用的工厂。

抛出：
IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小于 0，或者 maximumPoolSize 小于等于 0，或者 corePoolSize 大于 maximumPoolSize。
NullPointerException - 如果 workQueue 或 threadFactory 为 null。

allowCoreThreadTimeOut

public void allowCoreThreadTimeOut(boolean value)

如果在 保持活动时间内 没有任务到达，新任务到达时正在替换（如果需要），则设置 控制核心线程 是 超时 还是 终止 的策略。
1. 当为 false（默认值）时，由于没有传入任务，核心线程将永远不会中止。
2. 当为 true 时，适用于 非核心线程 的相同的  保持活动策略也同样适用于核心线程。
3. 为了避免连续线程替换，保持活动时间在设置为 true 时必须大于 0。
4. 通常应该在主动使用该池前调用此方法。

参数：
value - 如果应该超时，则为 true；否则为 false
抛出：
IllegalArgumentException - 如果 value 为 true 并且当前保持活动时间不大于 0。
从以下版本开始：
1.6