6、java5线程池之固定大小线程池newFixedThreadPool

 1 package com.yzl;
 2 
 3 import java.util.Random;
 4 import java.util.concurrent.Callable;
 5 import java.util.concurrent.ExecutorService;
 6 import java.util.concurrent.Executors;
 7 import java.util.concurrent.Future;
 8 import java.util.concurrent.TimeUnit;
 9 
10 public class ThreadPool {
11     public static void main(String[] args) {
12         fixedThreadPool();
13     }
14     
15     /**
16      * 固定大小的线程池
17      * 
18      * 同时可以处理【参数】个任务，多余的任务会排队，当处理完一个马上就会去接着处理排队中的任务。
19      */
20     private static void fixedThreadPool(){
21         ExecutorService es = Executors.newFixedThreadPool(2);
22         //加入5个任务
23         for(int i=1 ; i<5; i++){
24             final int task = i;
25             es.submit(new Runnable() {
26                 @Override
27                 public void run() {
28                     for(int j=1; j<=2; j++){
29                         System.out.println("现在运行的是第【 " + task + "】任务");
30                         System.out.println(Thread.currentThread().getName() + "is work , now loop to " + j);
31                         if(j==2){
32                             System.out.println("任务 【" + task + "】运行完成");
33                         }
34                         try {
35                             Thread.sleep(100);
36                         } catch (InterruptedException e) {
37                             e.printStackTrace();
38                         }
39                     }
40                 }
41             });
42         }
43         System.out.println("5个Runnable任务submit完成!!");
44 
45         //加入5个Callable任务，该任务执行完后是有返回值的则会发生堵塞，也就是取到5个任务的结果后才会继续往下走
46         for(int i=1 ; i<=5; i++){
47             final int task = i;
48             Future<Integer> future = es.submit(new Callable<Integer>() {
49                 @Override
50                 public Integer call() throws Exception {
51                     try {
52                         Thread.sleep(100);
53                     } catch (InterruptedException e) {
54                         e.printStackTrace();
55                     }
56                     System.out.println("Callable 任务【" + task + "】运行");
57                     return new Random().nextInt(100);
58                 }
59             });
60             
61             //如果注释取结果的代码，则不会堵塞
62             /*try {
63                 System.out.println("任务【" + i + "】返回的结果：" + future.get());
64             } catch (Exception  e) {
65                 e.printStackTrace();
66             }*/
67         }    
68         System.out.println("5个Callable任务submit完成!!" + System.currentTimeMillis() );
69         //虽然shutdown方法是等所有任务跑完后才真正停掉线程池，但该方法不会造成堵塞，也就是这代码运行后，下一行代码会立刻运行
70         es.shutdown();
71         System.out.println("主程序shutdown后退出!!" + System.currentTimeMillis());
72         
73         //暴力的直接终止线程池
74         //es.shutdownNow();
75         
76         //awaitTermination方法是堵塞式的，只有等真的把线程池停掉才会让程序继续往下执行
77         try {
78             es.awaitTermination(2, TimeUnit.SECONDS);
79         } catch (InterruptedException e) {
80             e.printStackTrace();
81         }
82         
83         System.out.println("主程序awaitTermination后退出!!" + System.currentTimeMillis()); 84  } 85 }

 1 5个Runnable任务submit完成!!
 2 现在运行的是第【 1】任务
 3 现在运行的是第【 2】任务
 4 pool-1-thread-1is work , now loop to 1
 5 pool-1-thread-2is work , now loop to 1
 6 5个Callable任务submit完成!!1441295848526
 7 主程序shutdown后退出!!1441295848526
 8 现在运行的是第【 2】任务
 9 pool-1-thread-2is work , now loop to 2
10 任务 【2】运行完成
11 现在运行的是第【 1】任务
12 pool-1-thread-1is work , now loop to 2
13 任务 【1】运行完成
14 现在运行的是第【 3】任务
15 pool-1-thread-2is work , now loop to 1
16 现在运行的是第【 4】任务
17 pool-1-thread-1is work , now loop to 1
18 现在运行的是第【 3】任务
19 pool-1-thread-2is work , now loop to 2
20 任务 【3】运行完成
21 现在运行的是第【 4】任务
22 pool-1-thread-1is work , now loop to 2
23 任务 【4】运行完成
24 Callable 任务【2】运行
25 Callable 任务【1】运行
26 Callable 任务【4】运行
27 Callable 任务【3】运行
28 Callable 任务【5】运行
29 主程序awaitTermination后退出!!1441295849228