自己封装的简单ThreadFactory

简介

自己封装的一个线程池工厂，能够比较方便的使用各种线程池，包括普通线程池、执行周期性任务线程池、单线程池，其中利用反射技术，可以直接传入函数名就可以执行，目前只支持无参函数的传入，也可以代码包装成Runnable传入。

结构与功能

整体结构如下图所示：

ThreadFactory里面包含有四个线程池，分别是
单线程池：线程池只有一个线程，所有任务依次执行；
周期任务线程池：用于执行周期性的任务；
默认线程池：核心线程数5个，最大线程数10个，保持时间3000ms；
自定义线程池：自定义核心线程数、最大线程数和保持时间；
源码地址：
https://git.oschina.net/huangbei1990/threadfactory.git
jar包的下载地址：
http://download.csdn.net/detail/hbdatouerzi/9880084

使用方法

public class Main {

    public static void main(String args[]){

        Main m = new Main();
        /**默认线程池*/
        //执行Main类里面的print函数
        ThreadFactory.getDefaultNormalPool().execute(m,"print");
        //执行Runnable任务
        ThreadFactory.getDefaultNormalPool().execute(new Runnable(){

            @Override
            public void run() {
                System.out.println("hello world!");
            }

        });

        /**自定义线程池*/
        ThreadFactory.initSelfPool(5, 5, 3000);
        ThreadFactory.getSelfPool().execute(m, "print");

        /**单线程池*/
        ThreadFactory.getSinglePool().execute(m,"print");

        /**周期性线程池*/
        //每隔0.5秒执行一次Runnable任务
        ThreadFactory.getScheduledPool().executeCycle(new Runnable(){

            @Override
            public void run() {
                System.out.println("schedulePool Hello World!");
            }

        }, 0, 500, "helloworld");

    }

    public void print(){
        System.out.println("hello world!!!");
    }

}

代码

代码的结构如下图所示：

ThreadPoolI接口

public interface ThreadPoolI {

    //提交任务，获取任务的执行情况
    public Future<?> submit(Runnable task);

    //执行任务，不关心任务的执行情况
    public void execute(Runnable task);

    //反射执行任务,不带参数
    public void execute(Object obj,String methodName);

    //提交反射任务，不带参数
    public Future<?> submit(Object obj,String methodName);

    //停止任务
    public boolean stopTask(Future<?> future);

}

AbstractThreadPool抽象线程池，实现反射功能

public abstract class AbstractThreadPool implements ThreadPoolI{

    //反射执行任务,不带参数
    public void execute(Object obj,String methodName){
        execute(constructRunnable(obj,methodName));
    }

    //提交反射任务，不带参数
    public Future<?> submit(Object obj,String methodName){
        return submit(constructRunnable(obj,methodName));
    }

    //停止任务
    public boolean stopTask(Future<?> future){
        if(future.isCancelled()){
            return true;
        }else{
            return future.cancel(true);
        }
    }

    //构造Runnable
    private Runnable constructRunnable(final Object obj,final String methodName){
        Runnable task = new Runnable() {

            @Override
            public void run() {
                try{
                    Method m = obj.getClass().getMethod(methodName);
                    m.invoke(obj);
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        };
        return task;
    }


}

单线程池

public class SingleThreadPool extends AbstractThreadPool{

    private ExecutorService executorService;

    public SingleThreadPool(){
        executorService = Executors.newSingleThreadExecutor();
    }

    @Override
    public Future<?> submit(Runnable task) {
        return this.executorService.submit(task);
    }

    @Override
    public void execute(Runnable task) {
        this.executorService.execute(task);
    }
}

周期性任务线程池

public class ScheduledThreadPool {

    private ScheduledExecutorService scheduledThreadPool;

    private Map<String, Future> futureMap = new HashMap<>();

    public ScheduledThreadPool(int scheduledPoolSize){
        scheduledThreadPool = Executors.newScheduledThreadPool(scheduledPoolSize);
    }

    //循环执行
    public void executeCycle(Runnable runnable, int delay, int period, String tag){
        Future future = this.scheduledThreadPool.scheduleAtFixedRate(runnable, delay, period, TimeUnit.MILLISECONDS);
        futureMap.put(tag, future);
    }

    //默认的循环执行,1秒执行一次
    public void defaultExecuteCycle(Runnable runnable){
        Future future = this.scheduledThreadPool.scheduleAtFixedRate(runnable,0,1000, TimeUnit.MILLISECONDS);
        futureMap.put(runnable.getClass().getName(),future);
    }

    //延迟执行
    public void executeDelay(Runnable runnable, int delay){
        this.scheduledThreadPool.schedule(runnable,delay, TimeUnit.MILLISECONDS);
    }

    //是否在线程池中执行
    public boolean isRunningInPool(String tag){
        if(futureMap.get(tag)!=null){
            return true;
        }else{
            return false;
        }
    }

    public void stopTask(String tag){
        Future future = this.futureMap.get(tag);
        if(future != null){
            future.cancel(true);
            futureMap.remove(tag);
        }
    }

    public void shutDown(){
        if(!scheduledThreadPool.isShutdown()) {
            this.scheduledThreadPool.shutdown();
        }
    }
}

普通线程池

public class ThreadPoolProxy extends AbstractThreadPool{

    ThreadPoolExecutor mExecutor;           // 只需要一个对象就行了
    private int         mCorePoolSize;
    private int         mMaximumPoolSize;
    private long        mKeepAliveTime;

    /*
     * 通过构造方法传入对应的corePoolSize,maximumPoolSize,keepAliveTime
     */
    public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long keepAliveTime) {
        super();
        mCorePoolSize = corePoolSize;
        mMaximumPoolSize = maximumPoolSize;
        mKeepAliveTime = keepAliveTime;
    }

    private void 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.DiscardPolicy();
                    mExecutor = new ThreadPoolExecutor(//
                            mCorePoolSize,// 核心线程数
                            mMaximumPoolSize,// 最大线程数
                            mKeepAliveTime, // 保持时间
                            unit, // 保持时间的单位
                            workQueue,// 工作队列
                            threadFactory,// 线程工厂
                            handler// 异常捕获器
                            );
                }
            }
        }
    }

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

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

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


}

线程池工厂

public class ThreadFactory {
    static ThreadPoolI  mdefaultNormalPool; // 默认的线程池
    static ThreadPoolI  mSelfPool;//自定义的线程池
    static ScheduledThreadPool mScheduledPool;//执行周期任务的线程池
    static ThreadPoolI mSinglePool;//单线程池

    /**创建了一个默认普通的线程池*/
    public static ThreadPoolI getDefaultNormalPool() {
        if (mdefaultNormalPool == null) {
            synchronized (ThreadFactory.class) {
                if (mdefaultNormalPool == null) {
                    mdefaultNormalPool = new ThreadPoolProxy(5, 10, 3000);
                }
            }
        }
        return mdefaultNormalPool;
    }

    /**自定义的普通线程池*/
    public static ThreadPoolI getSelfPool(){
        return mSelfPool;
    }

    /**初始化自定义线程*/
    public static boolean initSelfPool(int corePoolSize, int maximumPoolSize, long keepAliveTime){
        if (mSelfPool == null) {
            synchronized (ThreadFactory.class) {
                if (mSelfPool == null) {
                    mSelfPool = new ThreadPoolProxy(corePoolSize, maximumPoolSize, keepAliveTime);
                    return true;
                }
            }
        }
        return false;
    }

    /**创建一个执行周期性任务的线程池*/
    public static ScheduledThreadPool getScheduledPool(){
        if (mScheduledPool == null){
            synchronized (ScheduledThreadPool.class){
                if(mScheduledPool == null){
                    mScheduledPool = new ScheduledThreadPool(5);
                }
            }
        }
        return mScheduledPool;
    }

    //创建一个单线程池
    public static ThreadPoolI getSinglePool(){
        if(mSinglePool == null){
            synchronized (SingleThreadPool.class){
                if(mSinglePool == null){
                    mSinglePool = new SingleThreadPool();
                }
            }
        }
        return mSinglePool;
    }

}

总结

自己封装的线程池，使用方便，并且实现了直接传递函数名便可以使用多线程的功能。
传递有参函数的话，需要指定参数类型，暂时还未实现。