大白话理解，快速拿下JUC(六)

1、线程池简介

        

        线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销， 进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理 者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代 价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

        例子： 10 年前单核 CPU 电脑，假的多线程，像马戏团小丑玩多个球，CPU 需 要来回切换。 现在是多核电脑，多个线程各自跑在独立的 CPU 上，不用切换，效率高。

2、线程池的优势

         线程池做的工作只要是控制运行的线程数量，处理过程中将任 务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量， 超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

 3、它的主要特点为：

        a、 降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。

        b、 提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。

        c、 提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资 源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

4、线程池分类

        a、一池一线程，也叫单线程池

        b、一池N线程，也叫固定线程池，如设置4个线程池，他就总共4个线程

        c、可扩容线程池，可根据情况扩容的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class poolDemo {
    public static void main(String[] args) {
        /*****************一池N线程**********************/
        ExecutorService executorService1 = Executors.newFixedThreadPool(4);
        try {
            for (int i = 1; i <=10 ; i++) {
                executorService1.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在处理");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService1.shutdown();
        }
        /*****************一池一线程**********************/
        ExecutorService executorService2 = Executors.newSingleThreadExecutor();
        try {
            for (int i = 1; i <=10 ; i++) {
                executorService2.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在处理");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService2.shutdown();
        }
        /*****************可扩容线程**********************/
        ExecutorService executorService3 = Executors.newCachedThreadPool();
        try {
            for (int i = 1; i <=20 ; i++) {
                executorService3.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在处理");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService3.shutdown();
        }
    }
}

5、线程池的七大核心参数及四个拒绝策略

        请直接参考本人其他文章：线程池的七大核心参数大白话理解_九级代码狗的博客-CSDN博客

6、线程池执行流程

        如下图所示，比如现在线程池核心线程数是2，最大线程是5，队列是3的线程池，那么线程执行execute()之后创建线程，1和2请求会优先处理，再来345请求会进入队列中，在来一个678的线程的话，由于队列已满，还没有达到最大线程数，还有三个线程可以创建，创建线程工厂会再次创建三个线程去处理，第9个来的时候，由于队列已满，线程已全部占用，就会被执行黄色框内的拒绝策略

 7、为什么不让使用Executors去创建线程池，推荐使用自定义线程池

        因为Executors创建的线程的队列长度是Interger.MAX_VALUE的，在实际工作中，这样的策略会导致请求大量的堆积，从而导致OOM（内存溢出），以下代码是自定义线程的示例

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class poolDemo2 {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory());
        try {
            for (int i = 1; i <=10 ; i++) {
                threadPoolExecutor.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在处理");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPoolExecutor.shutdown();
        }

    }
}

8、Fork/Join合并分支

        Fork：拆分的意思，如100拆分成1-50  51-100的结果，拆分过程可以使用二分查找

        Join：把分拆任务的结果进行合并

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class forkjoin {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建拆分的类对象
        join join=new join(0,100);
        //创建合并分支池对象
        ForkJoinPool pool=new ForkJoinPool();
        //放入需要拆分合并的对象
        ForkJoinTask<Integer> submit = pool.submit(join);
        //获取最终合并结果
        int sumNumber = submit.get();
        System.out.println(sumNumber);
    }
}
//使用二分查找 计算0-100的计算综合 规则是两两相加的差值不能超过10
class join extends RecursiveTask<Integer> {
    //相差不大于数字
    private final int value=10;
    //开始数字
    private int begin;
    //结束数字
    private int end;
    //返回结果
    private int result;
    public join(int begin,int end){
        this.begin=begin;
        this.end=end;
    }
    @Override
    protected Integer compute() {
        //如果差值小于等于差值，则统计数据
        if((end-begin)<=value){
            for (int i = begin; i <=end ; i++) {
                result=result+i;
            }
        }else{
            //取中间值 100/2=50
            int model=(begin+end)/2;
            //拆分左边部分 0-50
            join right=new join(begin,model);
            //拆分右边部分 51-100
            join left=new join(model+1,end);
            //调用方法拆分
            right.fork();
            left.fork();
            result=right.join()+left.join();
        }
        return result;
    }
}

9、同步和异步

        同步：比如你去张三的班级找张三，张三不在，那么你会一直在他的座位等他回来

        异步：比如你去张三的班级找张三，张三不在，那么你会跟她们班级的同学说，等张三回来后告诉我一声，不需要等待

10、CompletableFuture的有返回值和无返回值的异步

        具体描述请移步我兄弟的博客juc并发编程入门(一)_我是一只代码狗的博客-CSDN博客

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //没有返回值得异步
        CompletableFuture.runAsync(()->{
            System.out.println(Thread.currentThread().getName()+"进行了操作runAsync");
        }).get();

        //有返回值的异步
        CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"进行了操作supplyAsync");
            return 1024;
        }).whenComplete((t,e)->{
            //t=返回值
            System.out.println(t);
            //e=异常信息，e=null是无异常的意思
            System.out.println(e);
        }).get();
    }
}