[Java] 线程池ThreadPoolExecutor使用简介与方法实例

threadpoolexecutor(int corepoolsize, int maximumpoolsize, 
long keepalivetime, timeunit unit, 
blockingqueue workqueue, 
rejectedexecutionhandler handler)

• corepoolsize： 线程池维护线程的最少数量
  
• maximumpoolsize：线程池维护线程的最大数量
  
• keepalivetime： 线程池维护线程所允许的空闲时间
  
• unit： 线程池维护线程所允许的空闲时间的单位
  
• workqueue： 线程池所使用的缓冲队列
  
• handler： 线程池对拒绝任务的处理策略
  

• 如果此时线程池中的数量小于corepoolsize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
  
• 如果此时线程池中的数量等于 corepoolsize，但是缓冲队列 workqueue未满，那么任务被放入缓冲队列。
  
• 如果此时线程池中的数量大于corepoolsize，缓冲队列workqueue满，并且线程池中的数量小于maximumpoolsize，建新的线程来处理被添加的任务。
  
• 如果此时线程池中的数量大于corepoolsize，缓冲队列workqueue满，并且线程池中的数量等于maximumpoolsize，那么通过 handler所指定的策略来处理此任务。
  

nanoseconds、microseconds、milliseconds、seconds。

• threadpoolexecutor.abortpolicy() 抛出java.util.concurrent.rejectedexecutionexception异常
  
• threadpoolexecutor.callerrunspolicy() 重试添加当前的任务，他会自动重复调用execute()方法
  
• threadpoolexecutor.discardoldestpolicy() 抛弃旧的任务
  
• threadpoolexecutor.discardpolicy() 抛弃当前的任务
  

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)
  {
  // 构造一个线程池
  threadpoolexecutor threadpool = new threadpoolexecutor(2, 4, 3, timeunit.seconds, new arrayblockingqueue<runnable>(3),
    new threadpoolexecutor.discardoldestpolicy());
  for (int i = 1; i <= producetaskmaxnumber; i++)
  {
    try
    {
    // 产生一个任务，并将其加入到线程池
    string task = "task@ " + i;
    system.out.println("put " + task);
    threadpool.execute(new threadpooltask(task));
    // 便于观察，等待一段时间
    thread.sleep(producetasksleeptime);
    }
    catch (exception e)
    {
    e.printstacktrace();
    }
  }
  }
}
/**
 * 线程池执行的任务
 */
class threadpooltask implements runnable, serializable
{
  private static final long serialversionuid = 0;
  private static int consumetasksleeptime = 2000;
  // 保存任务所需要的数据
  private object threadpooltaskdata;
  threadpooltask(object tasks)
  {
  this.threadpooltaskdata = tasks;
  }
  public void run()
  {
  // 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句
  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()
  {
  /* 
   * 创建线程池，最小线程数为2，最大线程数为4，线程池维护线程的空闲时间为3秒， 
   * 使用队列深度为4的有界队列，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除， 
   * 然后重试执行程序（如果再次失败，则重复此过程），里面已经根据队列深度对任务加载进行了控制。 
   */
  threadpoolexecutor tpe = new threadpoolexecutor(2, 4, 3, timeunit.seconds, new arrayblockingqueue<runnable>(queuedeep),
    new threadpoolexecutor.discardoldestpolicy());
  // 向线程池中添加 10 个任务
  for (int i = 0; i < 10; i++)
  {
    try
    {
    thread.sleep(1);
    }
    catch (interruptedexception e)
    {
    e.printstacktrace();
    }
    while (getqueuesize(tpe.getqueue()) >= queuedeep)
    {
    system.out.println("队列已满，等3秒再添加任务");
    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();
    }
  }
  }
}