浅谈Android线程池封装

Android项目当中经常会出现很多很多的我们需要使用子线程的情况，需要我们异步的加载数据或者实现UI视图和数据的绑定，但是我们又想减少资源的消耗，这个时候我们就需要引入线程池，而且我们的线程池尽量保证为单例

封装线程池ThreadPoolExecutor创建ThreadPoolProxy中间代理类，实现构造方法

 int  mCorePoolSize;
    int  mMaximumPoolSize;
    long mKeepAliveTime;

    ThreadPoolExecutor mThreadPoolExecutor;//只需要初始化一次

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

封装ThreadPoolExecutor，将必要参数从外界传入

private void initThreadPoolExecutor() {
        if (mThreadPoolExecutor == null || mThreadPoolExecutor.isShutdown() || mThreadPoolExecutor.isTerminated()) {
            synchronized (ThreadPoolProxy.class) {
                if (mThreadPoolExecutor == null || mThreadPoolExecutor.isShutdown() || mThreadPoolExecutor
                        .isTerminated()) {
                    TimeUnit unit = TimeUnit.MILLISECONDS;
                    BlockingQueue workQueue = new LinkedBlockingQueue();
                    ThreadFactory threadFactory = Executors.defaultThreadFactory();
                    RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy();
                    mThreadPoolExecutor = new ThreadPoolExecutor(
                            mCorePoolSize, //核心池的大小
                            mMaximumPoolSize, //最大线程数
                            mKeepAliveTime,//保持时间
                            unit,//保持时间的单位
                            workQueue,//工作队列
                            threadFactory,//线程工厂
                            handler//异常捕获器
                    );
                }
            }
        }
    }

实现ThreadPoolExecutor必要方法

 /**
     * 提交任务
     */
    public Future submit(Runnable task) {
        initThreadPoolExecutor();
        Future submitResult = mThreadPoolExecutor.submit(task);
        return submitResult;
    }


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

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

创建线程池工厂类，封装针对不同情况所有使用的线程池

/**
	 * 返回普通线程池的代理
	 * 双重检查加锁,保证只有第一次实例化的时候才启用同步机制,提高效率
	 * @return
	 */
	public static ThreadPoolProxy createNormalThreadPoolProxy() {
		if (mNormalThreadPoolProxy == null) {
			synchronized (ThreadPoolProxyFactory.class) {
				if (mNormalThreadPoolProxy == null) {
					mNormalThreadPoolProxy = new ThreadPoolProxy(5, 5, 3000);
				}
			}
		}
		return mNormalThreadPoolProxy;
	}

	/**
	 * 返回下载线程池的代理
	 */
	public static ThreadPoolProxy createDownloadThreadPoolProxy() {
		if (mDownloadThreadPoolProxy == null) {
			synchronized (ThreadPoolProxyFactory.class) {
				if (mDownloadThreadPoolProxy == null) {
					mDownloadThreadPoolProxy = new ThreadPoolProxy(3, 3, 3000);
				}
			}
		}
		return mDownloadThreadPoolProxy;
	}

这样一个线程池的工厂类就实现了，我们可以根据实际情况对于线程池代理类进行不同的封装，满足我们的需求！