ThreadPoolExecutor线程池

(1)、定义：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)

(2)、参数说明：

1. corePoolSize 指的是保留的线程池大小。
2. maximumPoolSize 指的是线程池的最大大小。
3. keepAliveTime 指的是空闲线程结束的超时时间。
4. unit 是一个枚举，表示 keepAliveTime 的单位。
   
5. workQueue 表示存放任务的队列。
   

    

6. RejectedExecutionHandler  添加任务失败后的执行策略,你可以调用线程池的 setRejectedExecutionHandler() 方法，用自定义的 RejectedExecutionHandler 对象替换现有的策略。

(3)、具体流程如下：

1. 　线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
   
2.    当调用 execute() 方法添加一个任务时，线程池会做如下判断：
   　　 a. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
   　　 b. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。
   　　 c. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；
   　　 d. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。
   
3.   当一个线程完成任务时，它会从队列中取下一个任务来执行。
   
4.   另外，当池子的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁。

(4)、排队有三种通用策略：

　　直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。  

(5)、添加任务失败后的4种执行策略

　　ThreadPoolExecutor.AbortPolicy：表示拒绝任务并抛出异常
　　ThreadPoolExecutor.DiscardPolicy：表示拒绝任务但不做任何动作
　　ThreadPoolExecutor.CallerRunsPolicy：表示拒绝任务，并在调用者的线程中直接执行该任务
　　ThreadPoolExecutor.DiscardOldestPolicy：表示先丢弃任务队列中的第一个任务，然后把这个任务加进队列。

eg:使用有界队列策略。
假设队列大小为 10，corePoolSize 为 3，maximumPoolSize 为 6，那么当加入 20 个任务时，执行的顺序就是这样的：首先执行任务 1、2、3，然后任务 4-13 被放入队列。这时候队列满了，任务 14、15、16 会被马上执行，而任务17-20则会添加失败。最终顺序是：1、2、3、14、15、16、4、5、6、7、8、9、10、11、12。

 1 public class ThreadPoolExe {  
 2       
 3     class Task implements Runnable {  
 4         private String name;  
 5         public Task(String name) {  
 6             this.name = name;  
 7         }  
 8         public void run() {  
 9             System.out.println("the "+ name + " task");  
10             try {  
11                 //模拟线程需要执行的时间  
12                 Thread.sleep(20000);  
13             } catch (InterruptedException e) {  
14                 // TODO Auto-generated catch block  
15                 e.printStackTrace();  
16             }  
17         }  
18     }  
19       
20     public void execute(){  
21         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3,6,3,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10),new ThreadPoolExecutor.DiscardPolicy());  
22         for(int i = 1; i<=20;i++) {  
23             Task task = new Task(""+i);  
24             threadPool.execute(task);  
25         }  
26     }  
27       
28     public static void main(String[] args) {  
29         ThreadPoolExe t = new ThreadPoolExe();  
30         t.execute();  
31     }  

输出结果：

the 1 task
the 3 task
the 2 task
the 14 task
the 15 task
the 16 task
the 4 task
the 6 task
the 5 task
the 7 task
the 8 task
the 9 task
the 10 task
the 13 task
the 11 task
the 12 task

ThreadPoolExecutor线程池

原文：http://www.cnblogs.com/lt132024/p/6442802.html