一.线程池的介绍

java中的池是非常重要的思想方法，比如内存池，进程池，连接池，常量池等等。本篇重点介绍java中的线程池。这里的这些池的概念都是一样的，比如做饭的时候，有烧水，切菜，炒菜等流程，如果等水烧开再去炒菜，切菜效率会很慢，但是可以烧水的同时去切菜，炒菜，效率大幅提升。如果我们需要频繁的创造和销毁线程，此时创建和销毁线程的成本就不能忽视了，因此可以使用线程池。提前创建好一波线程，后续需要用线程只需要从线程池中拿，线程用完后继续放到池子里面。思考一下为什么从池子里面取，就比从系统中创建线程更快更高效呢？

假如小明要去银行取钱，这个时候发现忘记复印身份证了，小明现在有2个选择，1是把身份证交给柜台服务人员由他们去复印，但服务人员手里同时要处理很多事情，等身份证复印完可能已经花费了很多时间，是不可控的行为。但是如果自己在大厅复印机上复印，复印的时间完全自己掌握，同时属于可控行为，效率大幅度提升。线程也是这样，如果从系统中创建线程，需要调用系统api,进一步由操作系统内核完成（内核相当于柜台），内核是给所有进程提供服务的，通常也需要处理很多事情，是不可控的。如果从线程池这里获取线程，上述内核中要做的操作，现在在获取线程的过程中，纯粹由用户代码完成。

二.java标准库的线程池

java标准库中也提供了现成的线程池
1.创建一个固定线程数的线程池

2.创建一个线程数目动态变化的线程池

3.创建单个线程的线程池

4.创建定时器效果的线程池

一.工产方法

看到这种写法是不是语法很难看懂，并没有new一个对象就直接调用方法。其实这种写法是java设计模式中的工产模式，一般创建对象都是通过new,通过构造方法。但是通过构造方法有重大缺陷，构造方法名字固定就是类名，有的类需要多种不同的方法构造，但是构造方法的名字又固定，就只能使用重载的方式来实现了，但是参数的个数和类型有差别。

一个坐标可以由横坐标和纵坐标组成，也可以由半径和角度描述，但是如果2个构造方法的参数和类型相同会报错，这也就是构造方法的一个缺陷，为了解决这个问题引入了工产模式。使用普通方法来构造对象，这样方法的名字就可以是任意的了，普通方法内部再来new对象，由于普通方法目的是为了创建出对象来，这样的方法一般是静态的。

接着看一个工产模式的实例：

interface Shape{void run(int a,int b,String str);
}
class Range implements Shape{public int x;public  int y;@Overridepublic void run(int x,int y,String str) {System.out.println("横纵坐标相加等于"+(x+y));}
}
class  Tangle implements  Shape{@Overridepublic void run(int r,int a,String str) {System.out.println("半径乘以角度等于"+r*a);}
}
class Point1{public static Shape PointXY(int x,int y,String str){if(str=="Range"){Range range = new Range();range.run(x,y,str);return range;}else if(str=="Tange"){Tangle tangle = new Tangle();tangle.run(x,y,str);return tangle;}return  null;}}
public class Test6 {public static void main(String[] args) {Shape shape = Point1.PointXY(2,3,"Range");Shape shape1 = Point1.PointXY(3,4,"Tange");}}

看懂上述代码在来看创建线程池的方式就立刻明白

点开源码

三.线程池的参数

1.int corePoolSize:核心线程数
ThreadPoolExecutor里面的线程个数并非是固定不变的，会根据当前的任务情况动态发生变化，corePoolSize至少得有这些线程，哪怕是你的线程池一点任务没有。

2.maximumPoolsize:最大线程数
ThreadPoolExecutor最多不能超过这些线程数，即使线程再忙。
3.longKeepAliveTime ,TimeUnit unit:最多等待时间，单位秒
当线程没有任务处理时，最多等待多少秒，等待时间一到如果还没有任务处理就会销毁。
4.BlockingQueue workQueue:线程内部有很多任务，这些任务可以使用阻塞队列来管理，线程池可以内置阻塞队列，也可以手动指定一个。
5.RejectedExecutionHandler handler:拒绝策略/拒绝方式（a,b,c,d）
a.线程池满了继续添加直接抛出异常，线程池之后不干活。

b.谁是添加这个新任务的线程，谁就去执行这个任务

c.丢弃最早的任务，执行新的任务

d.直接把新任务丢弃

四.线程池的实现

线程池计算斐波那契数列：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Fib{public static int create(int n){if(n<=1){return 1;}return create(n-1)+create(n-2);}
}
public class Test8 {public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(4);for(int i=0;i<10;i++){final int num=i;executorService.submit(()->{System.out.println("第"+num+"个斐波那契数是："+Fib.create(num)+",第"+num+"个线程是"+Thread.currentThread().getName());});}executorService.shutdown();}
}

从结果上看确实只是用到了4个线程去计算。

import java.util.concurrent.TimeUnit;public class Test9 {public static void main(String[] args) {RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.AbortPolicy();ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(4,10,30, TimeUnit.SECONDS,new LinkedBlockingDeque<>(), rejectedExecutionHandler);for(int i=0;i<5;i++){threadPoolExecutor.submit(()->{System.out.println(Thread.currentThread().getName());});}}
}

#五.自我模拟线程池

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;class ThreadPool2 {BlockingQueue<Runnable> blockingQueue = new LinkedBlockingDeque<>();public void submit(Runnable runnable) throws InterruptedException {blockingQueue.put(runnable);}public ThreadPool2(int n) {for (int i = 0; i < n; i++) {Thread thread = new Thread(() -> {while (true) {try {blockingQueue.take().run();} catch (InterruptedException e) {throw new RuntimeException(e);}}});thread.start();}}
}public class Test11 {public static void main(String[] args) throws InterruptedException {ThreadPool2 threadPool = new ThreadPool2(4);for (int i = 0; i < 10; i++) {threadPool.submit(new Runnable() {@Overridepublic void run() {System.out.println("hello");}});}}
}