10.线程池_线程调度

 1 /*
 2  * 一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度
 3  * 
 4  * 二、线程体系结构：
 5  * java.util.concurrent.Executor:负责线程的使用与调度的根接口
 6  *         |--**ExecutorService 子接口：线程池的主要接口
 7  *             |--ThreadPoolExecutor  线程池的实现类
 8  *             |--ScheduledExecutorSerice 子接口：负责线程的调度
 9  *                 |--ScheduledThreadPoolExecutor ： 继承ThreadPoolExecutor，实现 ScheduledExecutorService    
10  * 
11  * 三、工具类：Executors
12  * ExecutorService newFixedThreadPool()  :  创建固定大小的线程池
13  * ExecutorService newCachedThreadPool()  :  缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量
14  * ExecutorService newSingleThreadPool()  :  创建单个线程池  。线程池中只有一个线程
15  * 
16  * ScheduleExecutorService  new ScheduledThreadPool()  :  创建固定大小的线程池，可以延迟或定时执行任务
17  * */
18 public class TestThreadPool {
19     public static void main(String[] args) throws Exception {
20         // 1.创建线程池
21         ThreadPoolDemo tpd = new ThreadPoolDemo();
22         ExecutorService service = Executors.newFixedThreadPool(5);
23 
24         // 2。为线程池中的线程分配任务（实现 Callable<E>接口的任务）
25         List<Future<Integer>> results = new ArrayList<Future<Integer>>();
26         //执行多次任务，多次任务的返回值 构成一个 List
27         for(int i = 0;i < 10;i++) {
28             //通过 submit 方法 将任务放入线程池，交给线程池中的线程去执行
29             Future<Integer> result = service.submit(new Callable<Integer>() {
30                 @Override
31                 public Integer call() throws Exception {
32                     int sum = 0;
33                     for (int i = 0; i <= 10; i++) {
34                         sum = sum+ i;
35                     }
36                     return sum;
37                 }
38             });
39             results.add(result);
40         }
41          
42         
43         //3.获取call 返回的 数据
44         for(Future<Integer> result: results) {
45             System.out.println(Thread.currentThread().getName() + "  :  "+ result.get());
46         }
47         
48         //4.关闭线程池 （平缓的）（不关闭线程池，程序不会结束的）
49         service.shutdown();
50         
51 
52         // 2.为线程池中的线程分配任务 (为5个线程分配10个任务)
53         /*
54          * for(int i = 0;i < 10; i++) { service.submit(tpd); }
55          * 
56          * //3.关闭 线程池（平缓的） service.shutdown();
57          */
58     }
59 }
60 
61 class ThreadPoolDemo implements Runnable {
62     private int i = 100;
63 
64     @Override
65     public void run() {
66         while (i >= 0) {
67             System.out
68                     .println(Thread.currentThread().getName() + "  :  " + i--);
69         }
70     }
71 }

 1 public class TestScheduledThreadPool {
 2     public static void main(String[] args) throws Exception {
 3         // 创建 调度线程池
 4         ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
 5 
 6         for (int i = 0; i < 10; i++) {
 7             // 放入任务
 8             ScheduledFuture<Integer> result = service.schedule(   //schedule()  多了 几个参数，可以指定 延迟等待的时间 及 单位
 9                     new Callable<Integer>() {
10                         @Override
11                         public Integer call() throws Exception {
12                             int sum = 0;
13                             for (int i = 0; i < 100; i++) {
14                                 sum = sum + i;
15                             }
16                             System.out.println(Thread.currentThread().getName() + "   :   " + sum);
17                             return sum;
18                         }
19                     }, 3, TimeUnit.SECONDS);
20 
21             // 得到call 的结果
22             System.out.println(result.get());
23         }
24         
25         //关闭线程池
26         service.shutdown();
27 
28     }
29 }