为了提高代码的效率,我们经常会使用到线程池,那在实际项目工作中,如何将线程池与工厂模式和代理模式结合使用,使我们的代码更高效,更具有面象对象的思想,以及维护和拓展性更高呢?
接下来,我将结合下列代码讲讲我平时写项目时的写法,至于线程池是什么?工厂模式和代理模式的概念等,大家如何不知道的,可以在网上自己查下,这里就不做过多累赘的介绍。
首先,我们先来创建一个线程池代理类:
/**
* 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信息获知到我们的线程池创建的子线程运行了;
这种线程池与工厂模式和代理模式的结合在实际的项目开发中常用,也更加提高面向对象的编程思想,有利于代码的维护和拓展。