自己封装的简单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;    }}

总结

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