java多线程编程（四）-----线程池

一.线程池的介绍

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");
                }
            });
        }
    }
}