1. package demo;
   
2. 
   
3. import java.io.Serializable;
   
4. import java.util.concurrent.ArrayBlockingQueue;
   
5. import java.util.concurrent.ThreadPoolExecutor;
   
6. import java.util.concurrent.TimeUnit;
   
7. 
   
8. public class TestThreadPool{
   
9.         private static int produceTaskSleepTime=2;                                                //派发任务的间隔时间
   
10.         private static int consumeTaskSleepTime=2000;                                        //处理任务的速度
    
11.         private static int produceTaskMaxNumber=10;                                                //任务数量
    
12.        
    
13.         public  static void main(String[] args){
    
14.                 ThreadPoolExecutor threadPool=new ThreadPoolExecutor(
    
15.                                 2,                                                                                                        //池中所保存的线程数，包括空闲线程。
    
16.                                 4,                                                                                                        //池中允许的最大线程数
    
17.                                 3,                                                                                                        //当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
    
18.                                 TimeUnit.SECONDS,                                                                        // 参数的时间单位
    
19.                                 new ArrayBlockingQueue<Runnable>(3),                                //执行前用于保持任务的队列。此队列仅由保持 execute 方法提交的 Runnable 任务
    
20.                                 new ThreadPoolExecutor.DiscardOldestPolicy());                //由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
    
21.        
    
22.                 for(int i=1;i<=produceTaskMaxNumber;i++){
    
23.                         try{
    
24.                                 String task="task@"+i;
    
25.                                 System.out.println("派发任务"+task);
    
26.                                 threadPool.execute(new ThreadPoolTask(task));
    
27.                                 Thread.sleep(produceTaskSleepTime);                                        //发完任务休息时间
    
28.                         }catch(Exception e){
    
29.                                 e.printStackTrace();
    
30.                         }
    
31.                 }
    
32.         }
    
33.        
    
34.         public static class ThreadPoolTask implements Runnable,Serializable{                //任务接口（一个任务）
    
35.                 private static final long serialVersionUID = 1907601920449539447L;
    
36.                 private  Object threadPoolTaskData;
    
37.                 ThreadPoolTask(Object  tasks){
    
38.                         this.threadPoolTaskData=tasks;
    
39.                 }
    
40. 
    
41.                 @Override
    
42.                 public void run() {
    
43.                         System.out.println("start.."+threadPoolTaskData);
    
44.                         try{
    
45.                                 Thread.sleep(consumeTaskSleepTime);
    
46.                         }catch(Exception e){
    
47.                                 e.printStackTrace();
    
48.                         }
    
49.                         threadPoolTaskData=null;
    
50.                 }
    
51.                
    
52.                 public Object getTask(){
    
53.                         return this.threadPoolTaskData;
    
54.                 }
    
55.         }
    
56. }

复制代码

运行结果：
派发任务task@1
start..task@1
派发任务task@2
start..task@2
派发任务task@3
派发任务task@4
派发任务task@5
派发任务task@6
start..task@6
派发任务task@7
start..task@7
派发任务task@8
派发任务task@9
派发任务task@10
start..task@8
start..task@9
start..task@10


为什么有的任务没有执行到呢。？？求大师解！

这个还是看不懂。