JUC

ReentrantReadWriteLock 读写锁

• 概念

• 一个资源可以被多个读线程访问，或者可以被一个写线程访问，但是不能同时存在读写线程，读写互斥，读读共享提升性能，同时多人进行读操作

• 缺点：造成锁饥饿，一直读，没有写操作

• 读是共享锁，写独占锁

• 锁降级：写锁降级到读锁，读锁不能升级到写锁

阻塞队列

• 概念

• 队列：排队执行，先进先出

• 栈：先进后出，桶特性

• 阻塞队列，通过一个共享队列，可以是的数据由一端输入，从另外一端输出，特点：队列中元素达到峰值以后就阻塞状态，队列元素为空，消费线程处于等待状态

  

   

• 架构

• 继承 Colleciton,Iterable,Queue

• 子接口BlockingDequeue

• 常见的BlockingQueue

• ArrayBlockingQueue : 维护一个定长数组，由数组结构组成的有界阻塞队列

• LinkedBlockingQueue: 链表结构组成的有界（大小默认值为integer.Max_value)阻塞队列

• DelayQueue：使用优先级队列实现的延迟无界阻塞队列

• PriorityBlockingQueue: 支持优先级排序的无界阻塞队列

• SynchronousQueue: 不存储元素的阻塞队列，也即单个元素的队列

• LinkedTransferQueue: 由链表组成的无界阻塞队列

• LinkeddBlockingDeque: 由链表组成的双向阻塞队列

ThreadPool 线程池

• 优势、特点

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

• 特点：降低资源消耗，提高响应速度，提高线程的可管理性

• 架构图

  

   

• 线程池参数

• corePoolSize: 核心线程数量（常驻线程数量）（CPU密集型（计算大） ：cpu * 1.5 / cpu * 2  IO密集型:  cpu + 1  ）

• maxinumPoolSize: 最大线程数量

• keepAliveTime: 线程存活时间

• TimeUnit: 存活时间单位

• BlockingQueue: 阻塞队列

• ThreadFactory: 线程工厂

• RejectedExecutionHandler: 拒绝策略

• 执行流程

  

   

  1.执行execute()方法，线程run 方法执行任务

  2.创建核心线程，多余的线程放入阻塞队列中

  3.核心线程满了，阻塞队列满了，最大线程数没满，直接创建线程执行任务，如果三者都满了，则执行拒绝策略

• 拒绝策略

• AbortPolicy(默认)：直接抛出RejectedExceutionException异常阻止系统正常运行

• CallerRunsPolicy：调用者运行一种调节机制，不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量

• DiscardOldesPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务

• discardPolicy：该策略默默丢弃无法处理的任务，不处理也不抛异常

Fork/JOIN 分支合并

• 概念

• 可以将一个大的任务拆分成多个子任务进行处理，最后将任务结果集合并成最后的计算结果并输出，Fork: 把一个复杂的任务进行分拆，join:把分拆的任务结果进行合并

• 架构图

  

   

  

   

• 示例

package tx.forkjoin;

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

/**
 *
 */
class MyTask extends RecursiveTask<Integer> {
    //拆分差值不能超过10，计算10以内的运算
    public static final Integer VALUE = 10;
    private int begin;
    private int end;
    private int result;

    public MyTask(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }

    /**
     * The main computation performed by this task.
     * 拆分和合并过程
     *
     * @return the result of the computation
     */
    @Override
    protected Integer compute() {
        //判断相加的两个数值是否大于10
        if ((end - begin) <= VALUE) {
            for (int i = begin; i <= end; i++) {
                result = result + i;
            }
        } else { //拆分
            int middle = (begin + end) / 2;
            //拆分左边
            MyTask left = new MyTask(begin, middle);
            //拆分右边
            MyTask right = new MyTask(middle+1, end);
            //调用拆分方法
            left.fork();
            right.fork();
            result = left.join() + right.join();
        }
        return result;
    }
}

public class ForkJoinDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyTask myTask = new MyTask(0, 100);
        //创建分支合并池对象
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Integer> submit = pool.submit(myTask);
        Integer integer = submit.get();
        System.out.println(integer);
        pool.shutdown();
    }

}

CompletableFuture 异步回调

• 架构图

  

   

• 代码

       //同步调用
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName());
        });
        //异步调用
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 1 + 1;
        });
        // t 返回值  u 异常信息
        future.whenComplete((t, u) -> {
            System.out.println(t);
            System.out.println(u);
        }).get();