一.线程池的介绍
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;
@Override
public void run(int x,int y,String str) {
System.out.println("横纵坐标相加等于"+(x+y));
}
}
class Tangle implements Shape{
@Override
public 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() {
@Override
public void run() {
System.out.println("hello");
}
});
}
}
}
