JAVA线程池管理的实现

闲来无聊，总结一下自己对线程池理解。这里实现了线程池之外的任务缓冲队列
我看过很多项目，在实现线程池的时候超过缓冲队列大小时放弃最旧的未处理请求
总觉得不太好，现在加上外部缓冲队列看似解决了丢失任务问题确又产生了新的问题
关于异常任务会累积在队列还真不好处理。以后再看吧！！！

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池管理
 * @author LW
 * @date 2011-2-12
 */
public class ThreadPoolManager {
 
 private static ThreadPoolManager tpm = new ThreadPoolManager();

 // 线程池维护线程的最少数量
 private final static int CORE_POOL_SIZE = 3;

 // 线程池维护线程的最大数量
 private final static int MAX_POOL_SIZE = 10;

 // 线程池维护线程所允许的空闲时间
 private final static int KEEP_ALIVE_TIME = 0;

 // 线程池所使用的缓冲队列大小
 private final static int WORK_QUEUE_SIZE = 10;

 // 任务调度周期
 private final static int TASK_QOS_PERIOD = 10;

 // 任务缓冲队列
 private Queue<Runnable> taskQueue = new LinkedList<Runnable>();

 /*
  * 线程池超出界线时将任务加入缓冲队列
  */
 final RejectedExecutionHandler handler = new RejectedExecutionHandler() {
  public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {
   taskQueue.offer(task);
  }
 };

 /*
  * 将缓冲队列中的任务重新加载到线程池
  */
 final Runnable accessBufferThread = new Runnable() {
  public void run() {
   if (hasMoreAcquire()) {
    threadPool.execute(taskQueue.poll());
   }
  }
 };

 /*
  * 创建一个调度线程池
  */
 final ScheduledExecutorService scheduler = Executors
   .newScheduledThreadPool(1);

 /*
  * 通过调度线程周期性的执行缓冲队列中任务
  */
 final ScheduledFuture<?> taskHandler = scheduler.scheduleAtFixedRate(
   accessBufferThread, 0, TASK_QOS_PERIOD, TimeUnit.MILLISECONDS);

 /*
  * 线程池
  */
 final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
   CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS,
   new ArrayBlockingQueue<Runnable>(WORK_QUEUE_SIZE), this.handler);

 /*
  * 将构造方法访问修饰符设为私有，禁止任意实例化。
  */
 private ThreadPoolManager() {

 }

 /*
  * 线程池单例创建方法
  */
 public static ThreadPoolManager newInstance() {
  return tpm;
 }

 /*
  * 消息队列检查方法
  */
 private boolean hasMoreAcquire() {
  return !taskQueue.isEmpty();
 }

 /*
  * 向线程池中添加任务方法
  */
 public void addExecuteTask(Runnable task) {
  if (task != null) {
   threadPool.execute(task);
  }
 }
}

 

评论

7 楼 SINCE1978 2011-03-10  

我觉得这件事就不应该去做
服务器如果还有处理任务的余量大事线程池却满了，那属于你的线程池大小没有规划好的问题，一些用到线程池的服务端软件都有自己的一套帮助你规划好线程池尺寸的公式，如果你觉得直接抛弃最老任务的方式不好，是否可以给等待队列一个极大的尺寸？如果队列也满了，那说明存在其他问题，比如说处理的任务有死循环，或者是服务器硬件满足不了要求。这时再去解决该解决的问题。

6 楼 agapple 2011-03-08  

一种实现，复写execute和beforeExecute方法。

比如使用信号量或者原子变量控制，满了后可阻塞或者加入到自定义的taskQueue等。

5 楼 peak 2011-03-07  

concurrent包里面什么都写好了，何必我们去重写一遍呢

4 楼 henxingliwang 2011-03-07  

thebye85 写道

可以不用调度线程。重写ThreadPoolExecutor的afterExecute方法，将调度线程的代码移到该方法中。

这个想法很不错，不知道有没有人试过，可行度是多少....

3 楼 thebye85 2011-03-05  

可以不用调度线程。重写ThreadPoolExecutor的afterExecute方法，将调度线程的代码移到该方法中。

2 楼 jerry1985 2011-03-05  

vector 是线程安全的，不妨用这个？

1 楼 zhxing 2011-03-04  

// 任务缓冲队列
private Queue<Runnable> taskQueue = new LinkedList<Runnable>();

首先这个就不对了，LinkedList非线程安全。。

在实现线程池的时候超过缓冲队列大小时放弃最旧的未处理请求。。当池满后这个处理也是合理的。本身池满的情况应该是非常少出现，如果出现很多应该检查你的程序本身流程是否有问题。。