使用线程池主要基于这样的需求，因为创建一个线程因为涉及到与操作系统的交互，所以成本较高。当程序中需要大量而短暂的线程时应考虑使用线程池。


线程池工具类，


package com.chenjun.utils;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


/**
 * 线程池辅助类，整个应用程序就只有一个线程池去管理线程。
 * 可以设置核心线程数、最大线程数、额外线程空状态生存时间，阻塞队列长度来优化线程池。
 * 下面的数据都是参考Android的AsynTask里的数据。
 * @author zet
 *
 */
public class ThreadPoolUtils {
    
    private ThreadPoolUtils(){
        
    }
    
    //线程池核心线程数
    private static int CORE_POOL_SIZE = 5;
    
    //线程池最大线程数
    private static int MAX_POOL_SIZE = 100;
    
    //额外线程空状态生存时间
    private static int KEEP_ALIVE_TIME = 10000;
    
    //阻塞队列。当核心线程都被占用，且阻塞队列已满的情况下，才会开启额外线程。
    private static BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(
            10);
    
    //线程工厂
    private static ThreadFactory threadFactory = new ThreadFactory() {
        private final AtomicInteger integer = new AtomicInteger();

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "myThreadPool thread:" + integer.getAndIncrement());
        }
    };
    
    //线程池
    private static ThreadPoolExecutor threadPool;
    
    static {
        threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
                MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, workQueue,
                threadFactory);
    }
    
    
    /**
     * 从线程池中抽取线程，执行指定的Runnable对象
     * @param runnable
     */
    public static void execute(Runnable runnable){
        threadPool.execute(runnable);
    }

}


使用： 

ThreadPoolUtils.execute(new Runnable(){});


扩展，如果要进行取消操作：

将Runnable对象再进行封装成FutureTask。

FutureTask<Void> myTask = new FutureTask<Void>(new MyRunnable(), new Void());
ThreadPoolUtils.execute(myTask);

如果需要取消的话，myTask.cancel(true)。


ThreadPoolExecutor类：



1. public ThreadPoolExecutor(int corePoolSize,  
2. int maximumPoolSize,  
3. long keepAliveTime,  
4.                           TimeUnit unit,  
5.                           BlockingQueue<Runnable> workQueue,  
6.                           ThreadFactory threadFactory,  
7.                           RejectedExecutionHandler handler)


看这个参数很容易让人以为是线程池里保持corePoolSize个线程，如果不够用，就加线程入池直至maximumPoolSize大小，如果还不够就往workQueue里加，如果workQueue也不够就用RejectedExecutionHandler来做拒绝处理。

但实际情况不是这样，具体流程如下：

1）当池子大小小于corePoolSize就新建线程，并处理请求

2）当池子大小等于corePoolSize，把请求放入workQueue中，池子里的空闲线程就去从workQueue中取任务并处理

3）当workQueue放不下新入的任务时，新建线程入池，并处理请求，如果池子大小撑到了maximumPoolSize就用RejectedExecutionHandler来做拒绝处理

4）另外，当池子的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁