简介
自己封装的一个线程池工厂,能够比较方便的使用各种线程池,包括普通线程池、执行周期性任务线程池、单线程池,其中利用反射技术,可以直接传入函数名就可以执行,目前只支持无参函数的传入,也可以代码包装成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;
}
}
总结
自己封装的线程池,使用方便,并且实现了直接传递函数名便可以使用多线程的功能。
传递有参函数的话,需要指定参数类型,暂时还未实现。