一、说明
线程池的引出
- 通过new语句创建一个Java对象时，JVM就会为这个对象分配一块内存空间
- 而线程的创建和销毁需要调用操作系统内核的API，成本较高
- 线程池是一个容纳多个线程的容器，通过复用线程来达到执行多个任务的目的，对线程进行统一的分配，调优和监控，无需重复创建线程，优化了资源开销，由此引出
Executor框架
二、理解
Executor
java.util.cocurrent包下Executor接口，内部使用线程池机制，控制线程的启动、执行和关闭，相比Thread.start()方法效率更高，易于管理
包括三大部分
- 任务：被执行任务需要实现
Callable和Runnable接口
- 任务的执行：把任务分派给多个线程的执行机制，
Executor和ExecutorService接口及其实现类
- 异步计算的结果：
Future接口FutureTask实现类
Executor即线程池接口，其execute()方法接收Runnable接口的对象，但没有返回结果
ExecutorService接口用来实现和管理多线程，提供生命周期管理方法，返回 Future 对象，当所有已经提交的任务执行完毕后将会关闭该接口
AbstractExecutorService类用来提供线程接口的一些默认实现
ThreadPoolExecutor线程池的实现类，通过调用Executors创建线程池并返回一个ExecutorService对象
ScheduledExecutorService接口用来执行定时任务
ScheduledThreadPoolExecutor用来调度定时任务的线程池实现类
Executor框架使用流程
ExecutorService
- 继承
Executor接口
submit()方法接收Runnable和Callable接口的对象，有返回执行结果的对象
- 关闭线程池调用
shutDown()方法停止接收新任务，原来的任务继续执行；或者shutdownNow()方法停止接收新任务，原来的任务停止执行
Executors
- 线程池工厂类，提供生成Executor(线程池)的方法，返回的线程池都实现了
ExecutorService接口
newSingleThreadExecutor()创建单个线程的线程池
newFixedThreadPool(int numOfThreads)创建固定线程数的线程池，可控制线程最大并发数，超出的线程会在队列中等待
newCachedThreadPool()根据需要创建新的线程，自动回收空闲线程，所有线程都会在限制60秒后被回收，如果回收后又创建了任务，将新创建一个线程
newScheduledThreadPool(int)创建一个支持定时及周期性执行任务的线程池
三、实现
1. newSingleThreadExecutor
创建一个SingThreadExecutorTest类，单个线程的线程池执行MyThread1和MyThread2任务
public class SingThreadExecutorTest { public static void main(String[] args) { // 1.创建一个单线程化的线程池 ExecutorService executorService = Executors.newSingleThreadExecutor(); // 2.创建10次线程任务 for (int i = 0; i < 5; i++) { // 3.执行线程任务 executorService.execute(new MyThread1()); executorService.execute(new MyThread2()); } // 4.关闭线程池 executorService.shutdown(); } static class MyThread1 extends Thread { @Override public void run() { try { System.out.println(Thread.currentThread().getName() + " 我是任务1"); sleep(2000); } catch (Exception e) { e.printStackTrace(); } } } static class MyThread2 extends Thread { @Override public void run() { try { System.out.println(Thread.currentThread().getName() + " 我是任务2"); sleep(2000); } catch (Exception e) { e.printStackTrace(); } } } }
只有单个线程池去执行10个任务
2. newFixedThreadPool
创建固定线程数的线程池，可控制线程最大并发数，超出的线程会在队列中等待
public static void main(String[] args) { // 1.创建容量为5线程数的线程池 ExecutorService executorService = Executors.newFixedThreadPool(5); // 2.创建10次线程任务 for (int i = 0; i < 5; i++) { // 3.执行线程任务 executorService.execute(new MyThread1()); executorService.execute(new MyThread2()); } // 4.关闭线程池 executorService.shutdown(); }
5个线程去执行10个任务
3. newCachedThreadPool
根据需要创建新的线程，自动回收空闲线程，所有线程都会在限制60秒后被回收，如果回收后又创建了任务，将新创建一个线程
public static void main(String[] args) { // 1.创建可缓存的线程池 ExecutorService executorService = Executors.newCachedThreadPool(); // 2.创建10次线程任务 for (int i = 0; i < 5; i++) { // 3.执行线程任务 executorService.execute(new MyThread1()); executorService.execute(new MyThread2()); } // 4.关闭线程池 executorService.shutdown(); }
根据需要自动创建新线程去只执行10个任务
当线程运行时间超过60秒时
public static void main(String[] args) throws InterruptedException { // 1.创建可缓存的线程池 ExecutorService executorService = Executors.newCachedThreadPool(); // 2.创建线程任务执行 for (int i = 0; i < 5; i++) { executorService.execute(new MyThread1()); } Thread.sleep(30000); System.out.println("睡眠30秒"); for (int i = 0; i < 5; i++) { executorService.execute(new MyThread1()); } Thread.sleep(65000); System.out.println("睡眠65秒"); for (int i = 0; i < 5; i++) { executorService.execute(new MyThread1()); } // 4.关闭线程池 executorService.shutdown(); }
5个线程执行任务再休眠30秒后，线程并未被回收，继续用这5个线程执行任务，休眠65秒后，线程被回收，新建5个线程执行任务
4. newScheduledThreadPool
创建一个支持定时及周期性执行任务的线程池
public class SingThreadExecutorTest { public static void main(String[] args) { // 1.创建容量为5线程数的线程池 ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5); // 2.创建10次线程任务 for (int i = 0; i < 5; i++) { // 3.执行线程任务 executorService.schedule(new MyThread1(),5000 , TimeUnit.MILLISECONDS); executorService.schedule(new MyThread2(),1000 , TimeUnit.MILLISECONDS); }
5个线程去执行10个任务，任务2马上就执行完成了，而任务1要延迟5秒才执行完成
