Java多线程学习（七）

不念不忘少年蓝@ 2023-07-10 14:15 6阅读 0赞

## Java多线程学习（七） ##

2020.3.3学习总结

#### 1.为什么要使用线程池 ####

线程池优势:线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了线程池的最大线程数量，超出数量的线程排队等候，等其他线程执行完成后，再从队列中取出任务来执行。  
它的主要特点是：线程复用，控制最大并发数，管理线程。

*  降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
 *  提高响应速度。当任务到达时，任务可以不需要等待线程创建就可尽快执行。
 *  提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

#### 2. 线程池的使用 ####

1.架构图，Executor，Executors，ExecutorService，ThreadPoolExecutor  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70]

2.构造方法

执行长期任务性能好，创建一个线程池，一池拥有n个固定的线程，有固定线程数的线程池

ExecutorService executorService = Executors.newFixedThreadPool(int n);

一池拥有1个固定的线程，任务一个一个地执行

ExecutorService executorService = Executors.newSingleThreadExecutor();

执行很多短期异步任务，线程池根据需要创建新线程，但再先前构建的线程可以时将重用它们，可扩容。

ExecutorService executorService2 = Executors.newCachedThreadPool();

上述三个构造方法分别对应：  
（1）

public static ExecutorService newFixedThreadPool(int nThreads) { 
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }

（2）

public static ExecutorService newSingleThreadExecutor() { 
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }

（3）

public static ExecutorService newCachedThreadPool() { 
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
        }

#### 3.线程池的七大参数 ####

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler) { 
            if (corePoolSize < 0 ||
                maximumPoolSize <= 0 ||
                maximumPoolSize < corePoolSize ||
                keepAliveTime < 0)
                throw new IllegalArgumentException();
            if (workQueue == null || threadFactory == null || handler == null)
                throw new NullPointerException();
            this.acc = System.getSecurityManager() == null ?
                    null :
                    AccessController.getContext();
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.workQueue = workQueue;
            this.keepAliveTime = unit.toNanos(keepAliveTime);
            this.threadFactory = threadFactory;
            this.handler = handler;
        }

*  corePoolSize 线程池中的常驻核心线程数
 *  maximumPoolSize 线程池中能容纳同时执行的最大线程数，此值必须大于等于1
 *  keepAliveTime 多余的空闲线程的存活时间，当前线程池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程位置
 *  unit keepAliveTime的参数
 *  workQueue 任务队列（阻塞队列，相当于候客区），被提交但尚未被执行的任务，控制了线程的并发数
 *  threadFactory 表示生产线程池中工作线程的线程工厂，用于创建线程，一般默认即可
 *  handler 拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数时，如何来拒绝请求执行的Runnable的策略

#### 4.线程池的底层工作原理 ####

结合自己的理解，我画了一个这样的流程图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 1]  
（1）创建了线程池后，开始等待请求  
（2）当调用execute()方法添加一个请求任务时，线程池会做如下判断：

1.  如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
2.  如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务加入到阻塞队列中；
3.  如果阻塞队列满了，且正在运行的线程数量还小于maximumPoolSize，那么线程池会创建非核心线程来离立刻执行这个任务；
4.  如果队列满了，且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动拒绝策略来拒绝任务；

（3）当一个线程完成任务时，它会从队列中获取下一个任务来执行  
（4）当一个线程空闲，且超过了keepAliveTime时，线程池会判断：

1.  如果当前运行的线程数大于corePoolSize，那么这些空闲线程会被停止
2.  如果线程池的所有任务完成后，线程池中的线程都会收缩到corePoolSize的大小。

#### 5.线程池中如何设置合理参数 ####

1.使用哪种线程池？其实是一个也不用，而是自己手写。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 2]  
2.自定义一个线程池

package com.Zhongger.Day08;
    
    import java.util.concurrent.*;
    
    /** * @Author Zhongger * @Description 线程池 * @Date 20203.3 */
    public class ExecutorTest { 
        public static void main(String[] args) { 
           ExecutorService executorService = new ThreadPoolExecutor(
                    2,
                    5,
                    2L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingDeque<>(3),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy());
            for (int i = 0; i < 8; i++) { 
                executorService.execute(()->{ 
                    System.out.println(Thread.currentThread().getName()+"\t 执行任务");
                });
            }
        }
    }

上述自定义线程池中：  
corePoolSize=2 即核心线程数为2  
maximumPoolSize=5 即最大线程数为5，能够容纳的线程数为5  
keepAliveTime=2L，unit=TimeUtil.SECONDS 即非核心线程的存活时间为2秒  
workQueue=new LinkedBlockingDeque<>(3) 即阻塞队列中最大能容纳三个等待的任务  
threadFactory=Executors.defaultThreadFactory() 即创建线程的工厂为默认的线程工厂  
handler=new ThreadPoolExecutor.AbortPolicy() 即使用AbortPolicy拒绝策略

运行一波：

public static void main(String[] args) { 
           ExecutorService executorService = new ThreadPoolExecutor(
                    2,
                    5,
                    2L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingDeque<>(3),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy());
            for (int i = 0; i < 8; i++) { 
                executorService.execute(()->{ 
                    System.out.println(Thread.currentThread().getName()+"\t 执行任务");
                });
            }
        }

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 3]  
用到了五个线程，完成了8个任务。  
如果把任务数改一改，改成**i < 9**，运行一波，结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 4]  
显然，有一个任务被拒绝了。  
所以，得出一个结论，线程池可处理的最大任务数=maximumPoolSize+阻塞队列的最大容量数

#### 6.线程池的四大拒绝策略 ####

（1）AbortPolicy（默认）：直接抛出RejectedExecutionException异常，阻止系统正常运行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 5]  
（2）CallerRunsPolicy：运行者调用的一种调节机制，该策略不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 6]  
（3）DiscardPolicy：默默地丢弃无法处理的任务，不予任何处理也不抛出异常，如果允许任务丢失，这是最好的一种策略  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 7]  
（4）DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入到队列中，尝试再次提交当前任务

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 8]

#### 7.分支合并框架 ####

将一个复杂的任务拆分成多个小任务，再把小任务的结果合并，得到该复杂任务的结果。  
以下是计算0~100的和的案例：

package com.Zhongger.Day08;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.ForkJoinTask;
    import java.util.concurrent.RecursiveTask;
    
    /** * @Author Zhongger * @Description * @Date */
    public class ForkJoinDemo { 
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            MyTask myTask = new MyTask(0, 100);
    
            ForkJoinPool forkJoinPool = new ForkJoinPool();
    
            ForkJoinTask<Integer> forkJoinTask = forkJoinPool.submit(myTask);
    
            System.out.println(forkJoinTask.get());
    
            forkJoinPool.shutdown();
        }
    }
    class MyTask extends RecursiveTask<Integer>{ 
        private static final Integer ADJUST_VALUE=10;
    
        private int begin;
        private int end;
        private int result;
    
        public MyTask(int begin, int end) { 
            this.begin = begin;
            this.end = end;
        }
    
        @Override
        protected Integer compute() { 
            if ((end-begin)<=ADJUST_VALUE){ 
                for (int i = begin; i <= end; i++) { 
                    result=result+i;
                }
            }else { 
                int middle=(end+begin)/2;
                MyTask myTask1 = new MyTask(begin, middle);
                MyTask myTask2 = new MyTask(middle + 1, end);
                myTask1.fork();
                myTask2.fork();
                result=myTask1.join()+myTask2.join();
            }
            return result;
        }
    }

结果为：  
![在这里插入图片描述][20200303135519277.png]

#### 8.异步回调 ####

package com.Zhongger.Day08;
    
    import java.util.concurrent.CompletableFuture;
    import java.util.concurrent.ExecutionException;
    
    /** * @Author Zhongger * @Description * @Date */
    public class CompletableFutureDemo { 
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            //异步调用，无返回值
            CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "无返回值，update mysql ok");
            });
            completableFuture.get();
    
            //异步回调
            CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "无返回值，insert mysql ok");
                int flag=10/0;
                return 1024;
            }).whenComplete((t,u)->{ 
                System.out.println("t:"+t);
                System.out.println("u:"+u);
            }).exceptionally(f->{ 
                System.out.println("exception:"+f.getMessage());
                return 404;
            });//有返回值
            System.out.println(integerCompletableFuture.get());
        }
    }

#### 9.总结 ####

Java多线程的学习就暂告一段落了，掌握程度只能说是了解吧，后期还要多多巩固，并且多看看面试题，加油！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020030309182254.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200303110150729.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200303111858676.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020030311500296.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200303115136851.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200303120029774.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200303120019471.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200303120600513.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200303120654585.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[20200303135519277.png]: https://img-blog.csdnimg.cn/20200303135519277.png