ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, 
long keepAliveTime, TimeUnit unit, 
BlockingQueue workQueue, 
RejectedExecutionHandler handler) 

package demo;
import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestThreadPool2
{
  private static int produceTaskSleepTime = 2;
  private static int produceTaskMaxNumber = 10;
  public static void main(String[] args)
  {
    // 構(gòu)造一個線程池
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
        new ThreadPoolExecutor.DiscardOldestPolicy());
    for (int i = 1; i <= produceTaskMaxNumber; i++)
    {
      try
      {
        // 產(chǎn)生一個任務(wù)，并將其加入到線程池
        String task = "task@ " + i;
        System.out.println("put " + task);
        threadPool.execute(new ThreadPoolTask(task));
        // 便于觀察，等待一段時間
        Thread.sleep(produceTaskSleepTime);
      }
      catch (Exception e)
      {
        e.printStackTrace();
      }
    }
  }
}
/**
 * 線程池執(zhí)行的任務(wù)
 */
class ThreadPoolTask implements Runnable, Serializable
{
  private static final long serialVersionUID = 0;
  private static int consumeTaskSleepTime = 2000;
  // 保存任務(wù)所需要的數(shù)據(jù)
  private Object threadPoolTaskData;
  ThreadPoolTask(Object tasks)
  {
    this.threadPoolTaskData = tasks;
  }
  public void run()
  {
    // 處理一個任務(wù)，這里的處理方式太簡單了，僅僅是一個打印語句
    System.out.println(Thread.currentThread().getName());
    System.out.println("start .." + threadPoolTaskData);
    try
    {
      // //便于觀察，等待一段時間
      Thread.sleep(consumeTaskSleepTime);
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    threadPoolTaskData = null;
  }
  public Object getTask()
  {
    return this.threadPoolTaskData;
  }
}

package demo;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest
{
  private static int queueDeep = 4;
  public void createThreadPool()
  {
    /* 
     * 創(chuàng)建線程池，最小線程數(shù)為2，最大線程數(shù)為4，線程池維護(hù)線程的空閑時間為3秒， 
     * 使用隊(duì)列深度為4的有界隊(duì)列，如果執(zhí)行程序尚未關(guān)閉，則位于工作隊(duì)列頭部的任務(wù)將被刪除， 
     * 然后重試執(zhí)行程序（如果再次失敗，則重復(fù)此過程），里面已經(jīng)根據(jù)隊(duì)列深度對任務(wù)加載進(jìn)行了控制。 
     */ 
    ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueDeep),
        new ThreadPoolExecutor.DiscardOldestPolicy());
    // 向線程池中添加 10 個任務(wù)
    for (int i = 0; i < 10; i++)
    {
      try
      {
        Thread.sleep(1);
      }
      catch (InterruptedException e)
      {
        e.printStackTrace();
      }
      while (getQueueSize(tpe.getQueue()) >= queueDeep)
      {
        System.out.println("隊(duì)列已滿，等3秒再添加任務(wù)");
        try
        {
          Thread.sleep(3000);
        }
        catch (InterruptedException e)
        {
          e.printStackTrace();
        }
      }
      TaskThreadPool ttp = new TaskThreadPool(i);
      System.out.println("put i:" + i);
      tpe.execute(ttp);
    }
    tpe.shutdown();
  }
  private synchronized int getQueueSize(Queue queue)
  {
    return queue.size();
  }
  public static void main(String[] args)
  {
    ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
    test.createThreadPool();
  }
  class TaskThreadPool implements Runnable
  {
    private int index;
    public TaskThreadPool(int index)
    {
      this.index = index;
    }
    public void run()
    {
      System.out.println(Thread.currentThread() + " index:" + index);
      try
      {
        Thread.sleep(3000);
      }
      catch (InterruptedException e)
      {
        e.printStackTrace();
      }
    }
  }
}