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

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)

   {

     // 构造一个线程池

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

       }

     }

   }

}