1 .线程池类:TPTaskProxy
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class TPTaskProxy {
private static Log log = LogFactory.getLog(TPTaskProxy.class);
/**
* 添加任务并唤醒各因无任务而等待的空闲线程
*
* @param task
* @throws JobException
*/
public void executeTask(TPTask task) {
synchronized (taskQueue) {
try {
taskQueue.add(task);
taskQueue.notifyAll();
} catch (Exception e) {
}
}
}
public static int DEFAULT_POOL_SIZE = 10;
/**
* 任务队列
*/
private Queue<TPTask> taskQueue;
/**
* 空闲线程
*/
private Queue<TPTaskThread> idleThread;
/**
* 线程池大小
*/
private int taskPoolSize ;
public int getQueueSize(){
return taskQueue.size();
}
public TPTaskProxy() {
if (taskPoolSize < 0) {
this.taskPoolSize = DEFAULT_POOL_SIZE;
}
taskQueue = new ConcurrentLinkedQueue<TPTask>();
idleThread = new ConcurrentLinkedQueue<TPTaskThread>();
}
/**
* 初始化线程池,新建 N 个空闲线程
*
*/
public void init() {
log.debug("init");
log.debug("taskPoolSize="+taskPoolSize);
for (int i = 0; i < taskPoolSize; i++) {
TPTaskThread taskThread = new TPTaskThread(this, taskQueue,"Thread " + i);
idleThread.add(taskThread);
taskThread.start();
}
}
/**
* 关闭线程池,关闭线程池中各个线程 在调用该方法后,线程并没有马上关闭,而是在线程任务执行完之后关闭
*
*/
public void shutDown() {
synchronized (taskQueue) {
for (TPTaskThread thread : idleThread) {
thread.shutDown();
}
}
}
public void startAll() {
synchronized (taskQueue) {
for (TPTaskThread thread : idleThread) {
thread.setBegin(true);
}
taskQueue.notifyAll();
}
}
public void stopAll() {
synchronized (taskQueue) {
for (TPTaskThread thread : idleThread) {
thread.setBegin(false);
}
}
}
/**
* 获取空闲线程,当线程池内无空闲线程时等待
*
* @return
* @throws JobException
*/
public TPTaskThread getIdleThread(){
if (idleThread.isEmpty()) {
try {
idleThread.wait();
} catch (InterruptedException e) {
}
}
synchronized (idleThread) {
return idleThread.poll();
}
}
/**
* 释放线程
*
* @param thread
*/
public void releaseThread(TPTaskThread thread) {
synchronized (idleThread) {
idleThread.add(thread);
idleThread.notifyAll();
}
}
public void setTaskPoolSize(int taskPoolSize) {
this.taskPoolSize = taskPoolSize;
}
}
2 .线程实现类:TPTaskThread
import java.util.Queue;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class TPTaskThread extends Thread{
private static Log log = LogFactory.getLog(TPTaskThread.class);
/**
* 线程关闭的标识位
*/
private boolean shutDown = false;
private boolean begin = true;
/**
* 任务队列
*/
private Queue<TPTask> taskQueue;
private TPTaskProxy persistentProxy;
public TPTaskThread(TPTaskProxy persistentProxy,
Queue<TPTask> taskQueue, String name) {
super(name);
log.debug("make "+this);
System.out.println("make :::"+this);
this.taskQueue = taskQueue;
this.persistentProxy = persistentProxy;
}
public void shutDown() {
this.shutDown = true;
}
public void setBegin(boolean begin){
this.begin = begin;
}
public void run() {
while(!shutDown) {
TPTask task;
// 如果任务队列不为空,则取出一个任务并开始执行,否则线程等等
if(!taskQueue.isEmpty() && begin) {
synchronized(taskQueue) {
task = taskQueue.poll();
}
//多线程抢task,如果没有抢到,直接release.
if(task!=null)
task.doTask();
// 任务执行完毕之后释放线程到空闲线程队列中
persistentProxy.releaseThread(this);
} else {
try {
synchronized(taskQueue) {
taskQueue.wait();
}
} catch (InterruptedException e) {
}
}
}
}
}
3 .要执行的任务类:TPTask
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TPTask {
private Object target;
private String methodName;
private Object[] params;
private Class<?>[] types;
public TPTask(Object target,String methodName,Object[] params,Class<?>[] types){
this.target = target;
this.methodName = methodName;
this.params = params;
this.types = types;
}
public void doTask(){
try {
Method method = null;
if(params.length > 0)
method = target.getClass().getMethod(methodName, types);
else
method = target.getClass().getMethod(methodName);
method.invoke(target, params);
}
catch (SecurityException e) {
e.printStackTrace();
}
catch (NoSuchMethodException e) {
e.printStackTrace();
}
catch (IllegalArgumentException e) {
e.printStackTrace();
}
catch (IllegalAccessException e) {
e.printStackTrace();
}
catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
使用:
TPTaskProxy proxy = new TPTaskProxy();
//设置线程池的大小
int poolSize = 100;
proxy.setTaskPoolSize(poolSize);
proxy.init();
//目标对象,可以是任何类型对象
TargetObject target = new TargetObject();
proxy.executeTask(new TPTask(target,"methodName",
new Object[]{agr1, arg2,}
,new Class<?>[]{arg1.class,arg2.class}));