线程池的封装和使用（代理模式工厂模式）

通过线程池代理类和线程池工厂完成对线程池操作的解耦。
简单的代理模式和简单的工厂模式

1.创建一个代理类

public class ThreadPoolProxy {
    ThreadPoolExecutor  mExecutor;          // 只需创建一次
    int                 mCorePoolSize;
    int                 mMaximumPoolSize;
    long                mKeepAliveTime;

    public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long keepAliveTime) {
        super();
        mCorePoolSize = corePoolSize;
        mMaximumPoolSize = maximumPoolSize;
        mKeepAliveTime = keepAliveTime;
    }

    private ThreadPoolExecutor initThreadPoolExecutor() {//双重检查加锁
        if (mExecutor == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mExecutor == null) {
                    TimeUnit unit = TimeUnit.MILLISECONDS;
                    BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();// 无界队列
                    ThreadFactory threadFactory = Executors.defaultThreadFactory();
                    RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();// 丢弃任务并抛出RejectedExecutionException异常。
                    mExecutor = new ThreadPoolExecutor(//
                            mCorePoolSize,// 核心的线程数
                            mMaximumPoolSize,// 最大的线程数
                            mKeepAliveTime, // 保持时间
                            unit, // 保持时间对应的单位
                            workQueue,// 缓存队列/阻塞队列
                            threadFactory, // 线程工厂
                            handler// 异常捕获器
                    );
                }
            }
        }
        return mExecutor;
    }

    /**执行任务*/
    public void execute(Runnable task) {
        initThreadPoolExecutor();
        mExecutor.execute(task);
    }

    /**提交任务*/
    public Future<?> submit(Runnable task) {
        initThreadPoolExecutor();
        return mExecutor.submit(task);
    }

    /**移除任务*/
    public void removeTask(Runnable task) {
        initThreadPoolExecutor();
        mExecutor.remove(task);
    }
}

代理类将线程池单例化。并提供了几个核心的操作方法。属于将线程池构建的放法进行抽取。
2.创建工厂类

public class ThreadPoolFactory {
    static ThreadPoolProxy  mNormalPool;
    static ThreadPoolProxy  mDownLoadPool;

    /**得到一个普通的线程池*/
    public static ThreadPoolProxy getNormalPool() {
        if (mNormalPool == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mNormalPool == null) {
                    mNormalPool = new ThreadPoolProxy(5, 5, 3000);
                }
            }
        }
        return mNormalPool;
    }
    /**得到一个下载的线程池*/
    public static ThreadPoolProxy getDownLoadPool() {
        if (mDownLoadPool == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mDownLoadPool == null) {
                    mDownLoadPool = new ThreadPoolProxy(3, 3, 3000);
                }
            }
        }
        return mDownLoadPool;
    }
}

3.使用

ThreadPoolFactory.getDownLoadPool().execute(task);

希望能对开源框架的封装有一些启发。