本章主要记录讲解并发线程的线程池。java.util.concurrent工具包里面的工具类。
一：Executor框架：
Executors创建线程池的方法：
newFixedThreadPool()方法： 该方法返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中等待有空闲的线程去执行。newSingleThreadExecutor()方法：创建一个线程的线程池，若空闲则执行。若没有，则暂缓在任务队列中。newCachedThreadPool()方法：返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若用空闲的线程则执行任务，若无任务则不创建线程，并且每一个空闲线程会在60秒后自动回收。newScheduledThreadPool()方法：该方法返回一个SchededExecutorService对象，但该线程池可以指定线程的数量。newFixedThreadPool使用心得：因为该方法创建的是一个固定的线程池，底层运用的队列是linkBlockingQueue队列，该队列是阻塞无序队列，所以切记，当首次任务列队完成调度后，后面的顺序就会被打乱，排序则需要根据指定的规则排序。newCachedThreadExecutor使用心得：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newSingleThreadExecutor使用心得：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。newScheduledThreadPool使用心得：创建一个定长线程池，支持定时及周期性任务执行。
代码解析：
1 //Task内部类：
2
3 class Task extends Thread{
4
5 private int TaskId;
6
7 public Task(Integer TaskId){
8 this.TaskId=TaskId;
9 }
10 @Override
11 public void run() {
12 long start = System.currentTimeMillis();
13 try {
14 System.out.println("Run-----" +"TaskId:"+TaskId);
15 //模仿处理数据需要5s
16 Thread.sleep(5000);
17 long end = System.currentTimeMillis() - start;
18 System.out.println(" 执行时间：" + end);
19 } catch (InterruptedException e) {
20 // TODO Auto-generated catch block
21 e.printStackTrace();
22 }
23
24 }
25 }
26
27
1 // newFixedThreadPool方法测试：
2
3
4
5 /**
6 * newFixedThreadPool线程池测试 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。队列无序
7 * @throws InterruptedException
8 */
9 private static void FixedThredPoolTest() throws InterruptedException {
10 System.out.println("newFixedThreadPool线程池测试-------------------");
11 //创建固定的10个线程的线程池 队列阻塞无序
12 ExecutorService pool=Executors.newFixedThreadPool(10);
13 /**
14 * 这里产生15个任务 看是否一次性处理10个任务，
15 * 然后5个任务阻塞放在LinkBlockingQueue队列里面，
16 * 然后等10个任务处理完在执行
17 */
18 for (int i = 1; i <= 15; i++) {
19 // 执行给定的命令 执行任务
20 pool.execute(new Task(i));
21 }
22
23 //关闭启动线程
24 pool.shutdown();
25 // 等待子线程结束，再继续执行下面的代码
26 pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
27 System.out.println("all thread complete");
28 }
29
30
1 // newCachedThreadPool方法测试：
2
3
4
5 /**
6 * newCachedThreadPool线程池测试 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
7 * @throws InterruptedException
8 */
9 private static void CachedThreadPoolTest() throws InterruptedException {
10 System.out.println("newCachedThreadPool线程池测试-------------------");
11 ExecutorService pool=Executors.newCachedThreadPool();
12
13 for (int i =1; i <= 10; i++) {
14 // 执行给定的命令
15 pool.execute(new Task(i));
16 }
17 //关闭启动线程
18 pool.shutdown();
19 // 等待子线程结束，再继续执行下面的代码
20 pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
21 System.out.println("all thread complete");
22 }
23
24
1 // newSingleThreadExecutor方法测试：
2
3
4
5 /**
6
7 * newSingleThreadExecutor测试：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
8 * @throws InterruptedException
9 */
10 private static void SingleThreadPoolTest() throws InterruptedException {
11 System.out.println("newSingleThreadExecutor线程池测试-------------------");
12 ExecutorService pool=Executors.newSingleThreadExecutor();
13 for (int i = 1; i <= 5; i++) {
14 // 执行给定的命令
15 pool.execute(new Task(i));
16 }
17 //关闭启动线程
18 pool.shutdown();
19 // 等待子线程结束，再继续执行下面的代码
20 pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
21 System.out.println("all thread complete");
22 }
23
24
1 // newScheduledThreadPool方法测试：
2
3
4
5 /**
6 * newScheduledThreadPool测试 创建一个定长线程池，支持定时及周期性任务执行。
7 */
8 private static void ScheduledThreadPoolTest() {
9 System.out.println("newScheduledThreadPool线程池测试-------------------");
10 ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
11 /* 参数：
12 command - 要执行的任务
13 initialdelay - 首次执行的延迟时间
14 delay - 一次执行终止和下一次执行开始之间的延迟
15 unit - initialdelay 和 delay 参数的时间单位*/
16 ScheduledFuture<?> scheduleTask = scheduler.scheduleWithFixedDelay(new Task(1), 5, 1, TimeUnit.SECONDS);
17 }
18
19
