10.线程池_线程调度

Posted 2020-10-04 白日梦想家12138

/*线程池*/

/*第四种 获取线程的方法：线程池*/

一个ExecutorService，它使用线程池的可能的某个线程之一执行每个提交的任务，通常使用 Executors 工厂方法配置（ExecutorService service = Executors.newFixedThreadPool(5);）

线程池可以解决两个不同问题：

　　1.由于减少了每个任务的开销，它们通常可以在执行大量异步任务时 提供增强的性能，

　　2.并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。

为了便于跨大量上下文使用，此类提供了很多可调整的参数和扩展钩子（hook）.但是强烈建议 程序员使用较为方便的Executors 工厂方法

　　Executors.newCachedThreadPool() (无界线程池，可以进行自动线程回收)

　　Executors.newFixedThreadPool(int) (固定线程池大小)

　　Executors.newSingleThreadExecutors (单个后台线程)

它们均为 大多数 使用场景预定了一些默认设置（一般不用修改）。

一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度

二、线程体系结构：

　　一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度
*
*　　 二、线程体系结构：

* java.util.concurrent.Executor:负责线程的使用与调度的根接口

* |--**ExecutorService 子接口：线程池的主要接口

* |--ThreadPoolExecutor 线程池的实现类

* |--ScheduledExecutorSerice 子接口：负责线程的调度

* |--ScheduledThreadPoolExecutor ： 继承ThreadPoolExecutor，实现 ScheduledExecutorService
*
* 三、工具类：Executors

* ExecutorService newFixedThreadPool() : 创建固定大小的线程池

* ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量

* ExecutorService newSingleThreadPool() : 创建单个线程池 。线程池中只有一个线程

*
* ScheduleExecutorService new ScheduledThreadPool() : 创建固定大小的线程池，可以延迟或定时执行任务

/*使用线程池的是三个步骤*/

　　1.创建 线程池 （根据要求可以创建不同的线程池）

　　2.放入任务 （将任务交给线程池中的线程去执行）

　　3.关闭线程池 （一般需平缓关闭（等正在执行任务的线程执行完毕后））

 

 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 }

 

ScheduleExecutorService  new ScheduledThreadPool()  :  创建固定大小的线程池，可以延迟或定时执行任务

 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 }