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);
  }
 }
}