线程池与工厂模式、代理模式的结合使用

为了提高代码的效率，我们经常会使用到线程池，那在实际项目工作中，如何将线程池与工厂模式和代理模式结合使用，使我们的代码更高效，更具有面象对象的思想，以及维护和拓展性更高呢？

接下来，我将结合下列代码讲讲我平时写项目时的写法，至于线程池是什么？工厂模式和代理模式的概念等，大家如何不知道的，可以在网上自己查下，这里就不做过多累赘的介绍。

         首先，我们先来创建一个线程池代理类：

/**
 * des       线程池代理类，替线程池做一些操作，即可以暴露一些线程池本有的方法，
 *            也可以写一些对线程池的拓展方法。
 */
public class ThreadPoolProxy {

    ThreadPoolExecutor mThreadPoolExecutor;
    private int mCorePoolSize;
    private int mMaximumPoolSize;

    public ThreadPoolProxy(int corePoolSize,int maximumPoolSize){
        mCorePoolSize = corePoolSize;
        mMaximumPoolSize = maximumPoolSize;
    }
/**
 * @des 初始化线程池
 */
    private void initThreadPoolExecutor(){

        if(mThreadPoolExecutor==null||mThreadPoolExecutor.isShutdown()||mThreadPoolExecutor.isTerminated()){
            synchronized (ThreadPoolProxy.class){
                if(mThreadPoolExecutor==null||mThreadPoolExecutor.isShutdown()||mThreadPoolExecutor.isTerminated()){

                    long keepAliveTime = 0;//这里不保持时间
                    TimeUnit unit = TimeUnit.MILLISECONDS;//毫秒
                    BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();//无限队列
                    ThreadFactory threadFactory = Executors.defaultThreadFactory();//默认线程工厂

                    RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy();//这里不对异常进行处理
                    mThreadPoolExecutor = new ThreadPoolExecutor(
                            mCorePoolSize,//线程池核心数
                            mMaximumPoolSize,//最大线程数
                            keepAliveTime,//保持时间
                            unit,//时间单位
                            workQueue,//任务队列
                            threadFactory,//线程工厂
                            handler//异常捕获器
                            );
                }
            }
        }
    }

    /**
     * @des 提交任务
     * @param task
     * @return 得到异步执行完成之后的结果
     */
    public Future<?> submit(Runnable task){
        initThreadPoolExecutor();
        return mThreadPoolExecutor.submit(task);

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

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

在上面代码中，初始化线程池时，我使用了一个双重检查加锁的写法，在保证第一次同步初始化的同时，又提高了性能。

实际上，创建完线程池代理类之后，我们就可以直接通过new ThreadPoolProxy()来直接调用类中方法实现线程池的一些功能。但一般情况我不这么做，而且当需要创建几个处理不同模块事务的线程池时，这种做法就显得很不可取。

         所以一般我还会创建一个线程池代理工厂类来获取线程池代理工厂：

/**
 * des                  创建线程池代理的工厂类
 */
public class ThreadPoolProxyFactory {

    public static  ThreadPoolProxy mThreadPoolProxy;

    public static ThreadPoolProxy getThreadPoolProxy(){
        if(mThreadPoolProxy == null){
            synchronized (ThreadPoolProxyFactory.class){
                if(mThreadPoolProxy == null){
                    mThreadPoolProxy = new ThreadPoolProxy(3,3);
                }
            }
        }
        return mThreadPoolProxy;
    }
}

接下来，我们就可以直接通过工厂类，来获取到线程池代理。

public class MainActivity extends AppCompatActivity {

    private String TAG = getClass().getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //通过线程池代理工厂类获取线程池代理，再通过线程池代理去提交一个任务
        ThreadPoolProxyFactory.getThreadPoolProxy().submit(new MyTask());
    }
    
    class MyTask implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                Log.d(TAG,"线程任务："+i++);
            }
        }
    }
}

直接运行，可以通过打印出来的Log信息获知到我们的线程池创建的子线程运行了；

这种线程池与工厂模式和代理模式的结合在实际的项目开发中常用，也更加提高面向对象的编程思想，有利于代码的维护和拓展。