Java多线程学习（七）

Java多线程学习（七）

2020.3.3学习总结

1.为什么要使用线程池

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

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

2. 线程池的使用

1.架构图，Executor，Executors，ExecutorService，ThreadPoolExecutor

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.线程池的底层工作原理

结合自己的理解，我画了一个这样的流程图：

（1）创建了线程池后，开始等待请求
（2）当调用execute()方法添加一个请求任务时，线程池会做如下判断：

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

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

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

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

1.使用哪种线程池？其实是一个也不用，而是自己手写。

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 执行任务");
            });
        }
    }

结果如下：

用到了五个线程，完成了8个任务。
如果把任务数改一改，改成i < 9，运行一波，结果如下：

显然，有一个任务被拒绝了。
所以，得出一个结论，线程池可处理的最大任务数=maximumPoolSize+阻塞队列的最大容量数

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

（1）AbortPolicy（默认）：直接抛出RejectedExecutionException异常，阻止系统正常运行

（2）CallerRunsPolicy：运行者调用的一种调节机制，该策略不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。

（3）DiscardPolicy：默默地丢弃无法处理的任务，不予任何处理也不抛出异常，如果允许任务丢失，这是最好的一种策略

（4）DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入到队列中，尝试再次提交当前任务

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

结果为：

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