线程池

JAVA 线程池的类

1.Executor

线程管理接口

class SerialExecutor implements Executor {

 *   final Queue<Runnable> tasks = new ArrayDeque<Runnable>();

 *   final Executor executor;

 *   Runnable active;

 *

 *   SerialExecutor(Executor executor) {

 *     this.executor = executor;

 *   }

 *

 *   public synchronized void execute(final Runnable r) {

 *     tasks.offer(new Runnable() {

 *       public void run() {

 *         try {

 *           r.run();

 *         } finally {

 *           scheduleNext();

 *         }

 *       }

 *     });

 *     if (active == null) {

 *       scheduleNext();

 *     }

 *   }

 *

 *   protected synchronized void scheduleNext() {

 *     if ((active = tasks.poll()) != null) {

 *       executor.execute(active);

 *     }

 *   }

 * }}

2.ExecutorService extends Executor

提供线程管理服务

3.ThreadPoolExecutor

线程池执行类，该父类实现了ExecutorService

public ThreadPoolExecutor(int corePoolSize,

                              int maximumPoolSize,

                              long keepAliveTime,

                              TimeUnit unit,

                              BlockingQueue<Runnable> workQueue) {

        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

             Executors.defaultThreadFactory(), defaultHandler);

    }

这是ThreadPoolExecutor的构造函数，首先需要明白的是这几个参数的含义
A．    corePoolSize： 线程池维护线程的最少数量
B．    maximumPoolSize：线程池维护线程的最大数量
C．    keepAliveTime： 线程池维护线程所允许的空闲时间
D．    unit： 线程池维护线程所允许的空闲时间的单位
E．    workQueue： 线程池所使用的缓冲队列
F．    handler： 线程池对拒绝任务的处理策略

当一个任务添加到线程池的过程如下：
如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

也就是：处理任务的优先级为：
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue是BlockQueue的子类，ArrayBlockingQueue,DelayQueue

handler有四个选择(这不是android的Handler)：
ThreadPoolExecutor.AbortPolicy() – 这个也是AsyncTask.THREAD_POOL_EXECUTOR使用的
抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务，他会自动重复调用execute()方法
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务

class PausableThreadPoolExecutor extends ThreadPoolExecutor {

 *   private boolean isPaused;

 *   private ReentrantLock pauseLock = new ReentrantLock();

 *   private Condition unpaused = pauseLock.newCondition();

 *

 *   public PausableThreadPoolExecutor(...) { super(...); }

 *

 *   protected void beforeExecute(Thread t, Runnable r) {

 *     super.beforeExecute(t, r);

 *     pauseLock.lock();

 *     try {

 *       while (isPaused) unpaused.await();

 *     } catch (InterruptedException ie) {

 *       t.interrupt();

 *     } finally {

 *       pauseLock.unlock();

 *     }

 *   }

 *

 *   public void pause() {

 *     pauseLock.lock();

 *     try {

 *       isPaused = true;

 *     } finally {

 *       pauseLock.unlock();

 *     }

 *   }

 *

 *   public void resume() {

 *     pauseLock.lock();

 *     try {

 *       isPaused = false;

 *       unpaused.signalAll();

 *     } finally {

 *       pauseLock.unlock();

 *     }

 *   }

 * }}

3.Executors

提供静态方法创建不同类型的4大线程池，（注意该类比接口Executor多了个s.）

这4个线程池的区别主要在与BlockingQueue的处理方式不同.

使用方法就是Executors.xxx();

4大线程池之newCachedThreadPool

   public static ExecutorService newCachedThreadPool() {

        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                      60L, TimeUnit.SECONDS,

                                      new SynchronousQueue<Runnable>());

    }

4大线程池之newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {

        return new ThreadPoolExecutor(nThreads, nThreads,

                                      0L, TimeUnit.MILLISECONDS,

                                      new LinkedBlockingQueue<Runnable>());

    }

4大线程池之 newSingleThreadExecutor

   public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService

            (new ThreadPoolExecutor(1, 1,

                                    0L, TimeUnit.MILLISECONDS,

                                    new LinkedBlockingQueue<Runnable>()));

    }

4大线程池之newScheduledThreadPool

   public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService

            (new ThreadPoolExecutor(1, 1,

                                    0L, TimeUnit.MILLISECONDS,

                                    new LinkedBlockingQueue<Runnable>()));

    }