Java线程池

先写一个线程池工具类，暴露两个方法，一个是执行任务，另一个是取消执行任务。执行任务时，使用java的线程

池类去管理线程。

    public class ThreadPoolProxy {

        private ThreadPoolExecutor pool;
        private int corePoolSize;
        private int maximumPoolSize;
        private long time;

        public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long time) {
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.time = time;

        }
        /**
         * 执行任务
         * @param runnable
         */
        public void execute(Runnable runnable) {
            if (pool == null) {
                // 创建线程池
            /*
             * 1. 线程池里面管理多少个线程
             * 2. 如果排队满了, 额外的开的线程数
             * 3. 如果线程池没有要执行的任务 存活多久
             * 4. 时间的单位
             * 5. 如果 线程池里管理的线程都已经用了,剩下的任务 临时存到LinkedBlockingQueue对象中 排队
             */
                pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
                        time, TimeUnit.MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>(10));
            }
            pool.execute(runnable); // 调用线程池 执行异步任务
        }
        /**
         * 取消任务
         * @param runnable
         */
        public void cancel(Runnable runnable) {
            if (pool != null && !pool.isShutdown() && !pool.isTerminated()) {
                pool.remove(runnable); // 取消异步任务
            }
        }
    }

创建一个线程管理者，管理者提供两种线程池供用户选择，一种是较耗好时的线程，一种是一般耗时线程。应用单列模式，保证线程管理的只有一个实例。

public class ThreadManager {

    private ThreadPoolProxy longPool;
    private ThreadPoolProxy shortPool;

    private ThreadManager(){
    }

    private static class ThreadManegerHolder{
        private static final ThreadManager mThreadManager=new ThreadManager();
    }

    public static final ThreadManager getInstance(){
        return ThreadManegerHolder.mThreadManager;
    }

    // 比较耗时操作
    //最佳线程数=cpu的核数*2+1
    public synchronized ThreadPoolProxy createLongPool() {
        if (longPool == null) {
            longPool = new ThreadPoolProxy(5, 5, 5000L);
        }
        return longPool;
    }

    // 一般耗时操作
    public synchronized ThreadPoolProxy createShortPool() {
        if(shortPool==null){
            shortPool = new ThreadPoolProxy(3, 3, 5000L);
        }
        return shortPool;
    }
}

最后就是调用线程管理者去管理我们的线程了。

ThreadManager mThreadManager = ThreadManager.getInstance();
ThreadPoolProxy mShortPool = mThreadManager.createShortPool();
ThreadPoolProxy mLongPool = mThreadManager.createLongPool();
mShortPool.execute(new Runnable() {
    @Override
    public void run() {
        Log.e(TAG, "一般耗时操作");
    }
});

mLongPool.execute(new Runnable() {
    @Override
    public void run() {
        Log.e(TAG, "较耗时操作");
    }
});