JUC 并发编程学习笔记（下）

蔚落 2023-09-27 11:54 142阅读 0赞

#### 文章目录 ####

*  1. 四大函数式接口（必须掌握）
 *  2. Stream流式计算
 *  3. ForkJoin
 *  4. 异步回调
 *  5. JMM
 *  6. Volatile
 *  7. 单例模式
 *  8. 深入理解CAS
 *  9. 原子引用
 *  10. 各种锁的理解
 *   *  10.1 公平锁、非公平锁
     *  10.2 可重入锁
     *  10.3 自旋锁
     *  10.4 死锁

## 1. 四大函数式接口（必须掌握） ##

**lambda表达式、链式编程、函数式接口、Stream流式计算。**

> 函数式接口：只有一个方法的接口

@FunctionalInterface
    public interface Runnable {
        public abstract void run();
    }
    //超级多FunctionalInterface
    //简化编程模型，在新版本的框架底层大量应用！
    //foreach(消费者类型的函数式接口)

![在这里插入图片描述][3716360362f14725851436d24ea1a015.png_pic_center]  
  
测试代码如下：  
![在这里插入图片描述][e6bba52a1ff04278979b8f277f639ebf.png_pic_center]

/**
     * Function 函数型接口
     * 有一个输入参数，有一个输出
     * 只要是函数式接口，就可以用lambda表达式简化
     */
    public class Demo01 {
    
        public static void main(String[] args) {
            
            /* Function function = new Function<String, String>() {
                @Override
                public String apply(String str) {
                    return str;
                }
            };
            */
    
            Function<String, String> function = (str) -> {
                return str;
            };
            System.out.println(function.apply("abc"));
        }
    }

> 断定型接口: 有一个输入参数，返回值只能是 **布尔值**。

![在这里插入图片描述][de52bed529a047db99298102287cee25.png]  
  
测试代码如下：

/**
     * 断定型接口：有一个输入参数，返回值只能是布尔值！
     */
    public class Demo02 {
    
        public static void main(String[] args) {
            // 判断字符串是否为空
            /* Predicate<String> predicate = new Predicate<String>() {
                @Override
                public boolean test(String str) {
                    return str.isEmpty();
                }
            };*/
            Predicate<String> predicate = (str) -> {
                return str.isEmpty();
            };
            
            System.out.println(predicate.test(""));
        }
    }

> Consumer 消费型接口: 只有输入，没有返回值

![在这里插入图片描述][1dbe56be4e2349af8e9b06ab65eb97bf.png_pic_center]  
  
测试代码如下：

/**
     * Consumer 消费型接口： 只有输入，没有返回值
     */
    public class Demo03 {
    
        public static void main(String[] args) {
            /*Consumer<String> consumer = new Consumer<String>() {
                @Override
                public void accept(String str) {
                    System.out.println(str);
                }
            };*/
    
            Consumer<String> consumer = (str) -> {
                System.out.println(str);
            };
    
            consumer.accept("abcd");
        }
    }

> Supplier 供给型接口: 没有参数，只有返回值

![在这里插入图片描述][64d510e6976e4367bf6075562cda3f71.png_pic_center]  
  
测试代码如下：

/**
     * Supplier 供给型接口没有参数，只有返回值
     */
    public class Demo04 {
    
        public static void main(String[] args) {
    
            /* Supplier supplier = new Supplier<Integer>() {
                @Override
                public Integer get() {
                    System.out.println("get()");
                    return 1024;
                }
            }; */
    
            Supplier supplier = () -> {
                System.out.println("get()");
                return 1024;
            };
    
            System.out.println(supplier.get());
        }
    }

## 2. Stream流式计算 ##

什么是Stream流式计算  
大数据：存储 + 计算  
集合、MySQL本质就是存储东西的  
计算都应该交给流操作

![在这里插入图片描述][5bd3b46d2eef4a36b47ad12a7fc52cfe.png]

/**
     * 题目要求：一分钟内完成此题，只能用一行代码实现！
     * 现在有5个用户！筛选：
     * 1、ID必须是偶数
     * 2、年龄必须大于23岁
     * 3、用户名转为大写字母
     * 4、用户名字母倒着排序
     * 5、只输出一个用户！
     */
    public class Test {
        public static void main(String[] args) {
            User u1 = new User(1, "a", 21);
            User u2 = new User(2, "b", 22);
            User u3 = new User(3, "c", 23);
            User u4 = new User(4, "d", 24);
            User u5 = new User(6, "e", 25);
    
            //集合就是存储
            List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
    
            //计算交给stream流
            list.stream()
                    .filter(u -> {return u.getId() % 2 == 0;})
                    .filter(u -> {return u.getAge() > 23;})
                    .map(u -> {return u.getName().toUpperCase();})
                    .sorted((o1,o2)->{return o2.compareTo(o1);})
                    .limit(1)
                    .forEach(System.out::println);
        }
    }

## 3. ForkJoin ##

> 什么是ForkJoin？  
> 在JDK1.7中引入了一种新的Fork/Join线程池，它可以将一个大的任务拆分成多个小的任务并行执行并汇总执行结果。  
> Fork/Join采用的是分而治之的基本思想，分而治之就是将一个复杂的任务，按照规定的阈值划分成多个简单的小任务，然后将这些小任务的结果再进行汇总返回，得到最终的任务。

![在这里插入图片描述][36dd379a504e49ed8e18727e8053878c.png]

> ForkJoin特点：工作窃取

这个里面维护都是双端队列。  
![在这里插入图片描述][1a023f96e23f4f8a8051427018367906.png]

> ForkJoin

![在这里插入图片描述][37259540d5034127949a08747886a4de.png]  
  
![在这里插入图片描述][12ab6a3caeaa46ef8213de375c60e80f.png_pic_center]

/**
     * 求和计算的任务
     * 如何使用forkJoin
     * 1、ForkJoinPool通过它来执行
     * 2、计算任务 ForkJoinPool.execute(ForkJoinTask task)
     * 3、计算类要继承ForkJoinTask
     */
    public class ForkJoinDemo extends RecursiveTask<Long> {
    
        private Long start;
        private Long end;
        //临界值
        private Long temp = 10000L;
    
        public ForkJoinDemo(Long start, Long end) {
            this.start = start; // 1
            this.end = end;     // 1990900000
        }
    
        //计算方法
        @Override
        protected Long compute() {
            if ((end - start) < temp) {
                Long sum = 0L;
                for (Long i = start; i < end; i++) {
                    //分支合并计算
                    sum += i;
                }
                return sum;
            } else {
                //forkJoin 递归
                long mid = (start + end) / 2; //中间值
                ForkJoinDemo task1 = new ForkJoinDemo(start, mid);
                task1.fork(); //拆分任务，把任务压入线程队列
                ForkJoinDemo task2 = new ForkJoinDemo(mid + 1, end);
                task2.fork(); //拆分任务，把任务压入线程队列
                return task1.join() + task2.join();
            }
        }
    }

测试代码如下：

// 同一个任务效率高几十倍
    public class Test {
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //test1();
            //test2();
             test3();
        }
    
        // 普通 12224
        public static void test1() {
            long start = System.currentTimeMillis();
            Long sum = 0L;
            for (Long i = 1L; i <= 10_000_0000; i ++ ) {
                sum += i;
            }
            long end = System.currentTimeMillis();
            System.out.println("sum = " + sum + " 时间：" + (end - start));
        }
    
        //会使用ForkJoin的  10038
        public static void test2() throws ExecutionException, InterruptedException {
            long start = System.currentTimeMillis();
            ForkJoinPool forkJoinPool = new ForkJoinPool();
            ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
            ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务
            Long sum = submit.get();
    
            long end = System.currentTimeMillis();
            System.out.println("sum=" + sum + "时间：" + (end - start));
        }
    
        //Stream并行流()  153
        public static void test3() {
            long start = System.currentTimeMillis();
            LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
            long end = System.currentTimeMillis();
            System.out.println("sum = " + "时间：" + (end - start));
        }
    
    }

## 4. 异步回调 ##

> Future设计的初衷：可以对将来的某个事件的结果进行建模

![在这里插入图片描述][3b360d20df2d4ccd807b96a7ab9a34ab.png_pic_center]

1.  **没有返回值的runAsync异步回调**

代码如下：

public class Demo01 {
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //没有返回值的runAsync异步回调
            CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "runAsync -> Void");
            });
            System.out.println("111");
            completableFuture.get();  // 获取执行结果
        }
    }

1.  **有返回值的异步回调supplyAsync**

public class Demo02 {
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            // 有返回值的异步回调supplyAsync
            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("CompletableFuture");
                // int i = 10 / 0;
                return 1024;
            });
    
            System.out.println(completableFuture.whenComplete((t, u) -> {
                System.out.println("t==>" + t);     //正常的返回结果
                System.out.println("u==>" + u);     //错误的信息，java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
            }).exceptionally((e) -> {
                System.out.println(e.getMessage());
                return 233; //可以获取到错误的返回结果
            }).get());
    
        }
    }

**whenComplete:** 有两个参数，一个是 `t`， 一个是 `u`。  
`T`: 代表的是 **正常返回的结果**；  
`U`: 代表的是 **抛出异常的错误信息**；  
如果发生了异常， `get` 可以获取到 `exceptionally` 返回的值。

## 5. JMM ##

> 对Volatile的理解

`Volatile` 是 `Java` 虚拟机提供 **轻量级的同步机制**。  
1、保证可见性  
2、不保证原子性  
3、禁止指令重排

> 什么是JMM

JMM: Java 内存模型，不存在的东西、概念！约定！

**关于 JMM 的一些同步的约定：**  
1、线程解锁前，必须把共享变量立刻刷回主存。  
2、线程加锁前，必须读取主存中的最新值到工作内存中。  
3、加锁和解锁是同一把锁。

**8种操作：**  
![在这里插入图片描述][4afe77f36a2e48069599cd5db3f5cdc9.png]  
![在这里插入图片描述][bbf3487168b947dd9568e22ab929bd64.png]

**内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）**

*  lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态。
 *  unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
 *  read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。
 *  load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中。
 *  use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令。
 *  assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中。
 *  store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用。
 *  write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。

**JMM对这八种指令的使用，制定了如下规则：**

*  不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write。
 *  不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
 *  不允许一个线程将没有assign的数据从工作内存同步回主内存。
 *  一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作。
 *  一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁。
 *  如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值。
 *  如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量。
 *  对一个变量进行unlock操作之前，必须把此变量同步回主内存。

public class JMMDemo {
    
        private static int num = 0;
    
        public static void main(String[] args) {
            new Thread(() -> {
                while (num == 0) {
    
                }
            }).start();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num = 1;
            System.out.println(num);
        }
    }

问题：程序不知道主内存的值已经被修改过了。  
![在这里插入图片描述][837bc84b1d9c4819bd091e0cf722b80a.png_pic_center]

## 6. Volatile ##

> 1.  保证可见性

public class JMMDemo {
    
        // 不加 volatile 程序就会死循环
        // 加了 volatile 可以保证可见性
        private volatile static int num = 0;
        public static void main(String[] args) { // main 线程
            new Thread(() -> { // 线程1 对主内存的变化是不知道的
                while (num == 0) {
    
                }
            }).start();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num = 1;
            System.out.println(num);
        }
    }

> 1.  不保证原子性

原子性：不可分割  
线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败。

**代码如下：**

// 不保证原子性
    public class VDemo {
        // volatile 不保证原子性
        private volatile static int num = 0;
    
        public static void add() {
            num ++; // 不是原子性操作
        }
    
        public static void main(String[] args) {
            // 理论上num结果为20000
            for (int i = 0; i < 20; i ++ ) {
                new Thread(() -> {
                    for (int j = 0; j < 1000; j ++ ) {
                        add();
                    }
                }).start();
            }
            while (Thread.activeCount() > 2) {
                Thread.yield();
            }
    
            System.out.println(Thread.currentThread().getName() + " " + num);
        }
    }

**如果不加lock和synchronized,怎么样保证原子性?**  
![在这里插入图片描述][2d12ee2f19684a3a9a6f3ba458b503c6.png]

> 原子类为什么这么高级？

public class VDemo02 {
        // volatile 不保证原子性
        // 原子类的
        private volatile static AtomicInteger num = new AtomicInteger();
    
        public static void add() {
            //num ++; // 不是原子性操作
            num.getAndIncrement(); // Atomicnteger + 1 方法
        }
    
        public static void main(String[] args) {
            // 理论上num结果为20000
            for (int i = 0; i < 20; i ++ ) {
                new Thread(() -> {
                    for (int j = 0; j < 1000; j ++ ) {
                        add();
                    }
                }).start();
            }
            while (Thread.activeCount() > 2) {
                Thread.yield();
            }
    
            System.out.println(Thread.currentThread().getName() + " " + num);
        }
    }

这些类的底层都直接和操作系统挂钩！在内存中修改值 ！ `Unsafe` 类是一个很特殊的存在！

> 1.  指令重排

什么是指令重排： **你写的程序，计算机并不会按照你写的那样去执行的。**  
源代码 -> 编译器优化的重排 -> 指令并行也可能会重排 -> 内存系统也会重排 -> 执行。  
**处理器在进行指令重排的时候会考虑一个问题，考虑：数据之间的依赖性！**

int x = 1; //1
    int y = 2; //2
    x = x + 5; //3
    y = x * x; //4
    
    我们所期望的：1234 但是可能执行的时候会变成 2134 1324 
    可不可能是  4123！

可能造成影响的结果: a b x y 这四个值默认都是0；

正常的结果：x = 0; y = 0.

指令重排导致的结果： x = 2; y = 1.

**`volatile` 可以避免指令重排：**  
内存屏障，CPU指令，作用：  
1、保证特定的操作的执行顺序。  
2、可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）。

![在这里插入图片描述][85704f5295c941ecabf10ea1e7f3866b.png_pic_center]  
  
**Volatile是可以保证可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！**

## 7. 单例模式 ##

> 饿汉式

//饿汉式单例
    public class Hungry {
    
        //可能会浪费空间
        private byte[] data1 = new byte[1024 * 1024];
        private byte[] data2 = new byte[1024 * 1024];
        private byte[] data3 = new byte[1024 * 1024];
        private byte[] data4 = new byte[1024 * 1024];
    
        private Hungry() {
    
        }
    
        private final static Hungry HUNGRY = new Hungry();
    
        public static Hungry getInstance() {
            return HUNGRY;
        }
    }

> DCL懒汉式

//懒汉式单例模式
    public class LazyMan {
    
        private static boolean sign = false;
    
        private LazyMan() {
            synchronized (LazyMan.class) {
                if (sign == false) {
                    sign = true;
                } else {
                    throw new RuntimeException("不要试图使用反射破坏异常");
                }
            }
            System.out.println(Thread.currentThread().getName() + "OK");
        }
    
        private static LazyMan lazyMan;
    
        //双重检测锁模式的懒汉式单例 简称DCL懒汉式
        public static LazyMan getInstance() {
            if (lazyMan == null) {
                synchronized (LazyMan.class) {
                    if (lazyMan == null) {
                        lazyMan = new LazyMan();        //不是一个原子性操作
                    }
                }
            }
    
            return lazyMan;
        }
    }
        /**
         * 1.分配内存空间
         * 2.执行构造方法，初始化对象
         * 3.把这个对象指向这个空间
         * <p>
         * 期望 123
         * 执行 132 A
         * B   //此时lazyMan还没有完成构造
         */

> 静态内部类

//静态内部类
    public class Holder {
        private Holder() {
    
        }
    
        public static Holder getInstance() {
            return InnerClass.HOLDER;
        }
    
        public static class InnerClass {
            private static final Holder HOLDER = new Holder();
        }
    }

> 单例不安全，因为有反射  
> 枚举

//enum 是一个什么？本身也是一个Class类
    public enum EnumSingle {
        INSTANCE;
    
        public EnumSingle getInstance() {
            return INSTANCE;
        }
    }
    
    class Test {
        public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
            EnumSingle instance1 = EnumSingle.INSTANCE;
            Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
            declaredConstructor.setAccessible(true);
            EnumSingle instance2 = declaredConstructor.newInstance();
            // NoSuchMethodException: com.kuang.single.EnumSingle.<init>()
            System.out.println(instance1);
            System.out.println(instance2);
        }
    }

![在这里插入图片描述][67de19d7b9cc4cd595e4ceb856c897ad.png_pic_center]

> 枚举类型的最终反编译源：

public final class EnumSingle extends Enum
    {
    
        public static EnumSingle[] values()
        {
            return (EnumSingle[])$VALUES.clone();
        }
    
        public static EnumSingle valueOf(String name)
        {
            return (EnumSingle)Enum.valueOf(com/kuang/single/EnumSingle, name);
        }
    
        private EnumSingle(String s, int i)
        {
            super(s, i);
        }
    
        public EnumSingle getInstance()
        {
            return INSTANCE;
        }
    
        public static final EnumSingle INSTANCE;
        private static final EnumSingle $VALUES[];
    
        static 
        {
            INSTANCE = new EnumSingle("INSTANCE", 0);
            $VALUES = (new EnumSingle[] {
                INSTANCE
            });
        }
    }

## 8. 深入理解CAS ##

> 什么是CAS？  
> CAS的全称为 `Compare-And-Swap`，直译就是对比交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口。    
> 简单解释：CAS操作需要输入两个数值，一个旧值(期望操作前的值)和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。

![在这里插入图片描述][63b2bd39db56464d84ef72ae9e73051c.png_pic_center]  
  
![在这里插入图片描述][c4926af4aa9e48d7a1f668b0e0aa34be.png]  
  
![在这里插入图片描述][2ce6fb45f0434ba1b2066563cf1a6088.png]  
  
CAS: 比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！

**缺点：**  
1、循环会耗时  
2、一次性只能保证一个共享变量的原子性  
3、ABA问题

> CAS:ABA问题（狸猫换太子）

![在这里插入图片描述][8d0c52e408f842ee926ac1279d5c5331.png]  
  
测试代码 如下：

public class CASDemo {
    
        // CAS  compareAndSet: 比较并交换
        public static void main(String[] args) {
            AtomicInteger atomicInteger = new AtomicInteger(2020);
    
            // 期望，更新
            //public final boolean compareAndSet(int expectedValue, int newValue)
            // 如果我期望的值达到了，那么就更新，否则不更新
    
            // ==============捣乱的线程======
            System.out.println(atomicInteger.compareAndSet(2020, 2021));
            System.out.println(atomicInteger.get());
    
            System.out.println(atomicInteger.compareAndSet(2021, 2020));
            System.out.println(atomicInteger.get());
    
            // ==============期望的线程======
            System.out.println(atomicInteger.compareAndSet(2020, 6666));
            System.out.println(atomicInteger.get());
        }
    }

## 9. 原子引用 ##

> 解决ABA问题，引入原子引用！对应的思想是乐观锁。

带版本号的操作！

**注意：**  
**Integer使用了对象缓存机制，默认范围是-128~-127，推荐使用静态工厂方法valueOf获取对象实例，而不是new，因为valueOf使用缓存，而new一定会创建新的对象分配新的内存空间。**  
![在这里插入图片描述][01a8684d2c7e4f9f97e361164d163af2.png]

测试代码如下：

public class CASDemo {
    
        //CAS       compareAndSet:比较并交换
        public static void main(String[] args) {
            // AtomicStampedReference   注意：如果泛型是一个包装类，注意对象的引用问题
            // 正常在业务操作，这里比较的都是一个对象
            AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);
    
            new Thread(() -> {
                int stamp = atomicStampedReference.getStamp();       //获得版本号
                System.out.println("a1 =>" + stamp);
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(atomicStampedReference.compareAndSet(1, 2,
                        atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
    
                System.out.println("a2 =>" + atomicStampedReference.getStamp());
    
                System.out.println(atomicStampedReference.compareAndSet(2, 1,
                        atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
                System.out.println("a3 =>" + atomicStampedReference.getStamp());
            }, "a").start();
    
            //乐观锁的原理相同
            new Thread(() -> {
                int stamp = atomicStampedReference.getStamp();       //获得版本号
                System.out.println("b1 =>" + stamp);
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(atomicStampedReference.compareAndSet(1, 6, stamp,
                        stamp + 1));
                System.out.println("b2 =>" + atomicStampedReference.getStamp());
            }, "b").start();
    
    
        }
    }

运行结果如下：  
![在这里插入图片描述][fda83c1d10f14f7e8eb10a25f3973818.png]

## 10. 各种锁的理解 ##

### 10.1 公平锁、非公平锁 ###

公平锁：非常公平，不能插队，必须先来后到！  
非公平锁：非常不公平，可以插队（**默认都是非公平的**）

public ReentrantLock() {
            sync = new NonfairSync();
    }
    
    
    public ReentrantLock(boolean fair) {
            sync = fair ? new FairSync() : new NonfairSync();
        }

### 10.2 可重入锁 ###

可重入锁（递归锁）  
![在这里插入图片描述][04d5d5c570614568ba0f25f6628d0a71.png]

> synchronized 版

代码如下：

//Synchronized
    public class Demo01 {
        public static void main(String[] args) {
            Phone phone = new Phone();
    
            new Thread(() -> {
                phone.sms();
            }, "A").start();
    
            new Thread(() -> {
                phone.sms();
            }, "B").start();
        }
    }
    
    class Phone {
    
        public synchronized void sms() {
            System.out.println(Thread.currentThread().getName() + " sms");
            call(); //这里也有锁
        }
    
        public synchronized void call() {
            System.out.println(Thread.currentThread().getName() + " Call");
        }
    }

运行结果如下：  
![在这里插入图片描述][3ed2200faedd4a7695984d42f78cf534.png]

> lock版

代码如下：

// lock
    public class Demo02 {
        public static void main(String[] args) {
            Phone2 phone = new Phone2();
    
            new Thread(() -> {
                phone.sms();
            }, "A").start();
    
            new Thread(() -> {
                phone.sms();
            }, "B").start();
        }
    }
    
    class Phone2 {
        Lock lock = new ReentrantLock();
    
        public void sms() {
            try {
                lock.lock();        //细节问题：lock.lock();      lock.unlock();
                // lock 锁必须配对 ，否则就会死在里面
                System.out.println(Thread.currentThread().getName() + " sms");
                call(); //这里也有锁
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
    
        }
        public  void call() {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " Call");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

运行结果如下：  
![在这里插入图片描述][3bd76a7bd9cf42d6ade30e421ea5b640.png]

### 10.3 自旋锁 ###

`spinlock`:

![在这里插入图片描述][9f9de97c60b549af95cb61520fb49c5c.png]  
  
自定义一个锁测试：

//自旋锁
    public class SpinlockDemo {
        //int 0
        //Thread null
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
    
        //加锁
        public void myLock() {
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName() + "=> mylock");
            //自旋锁
            while (!atomicReference.compareAndSet(null, thread)) {
    
            }
        }
    
        //解锁
        public void myUnLock() {
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName() + "=> myUnlock");
    
            atomicReference.compareAndSet(thread, null);
    
        }
    }

测试代码如下：

public class TestSpinLock {
        public static void main(String[] args) throws InterruptedException {
    /*        ReentrantLock reentrantLock = new ReentrantLock();
            reentrantLock.lock();
            reentrantLock.unlock();*/
    
            //底层使用的自旋锁CAS
            SpinlockDemo lock = new SpinlockDemo();
    
            new Thread(() -> {
                lock.myLock();
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.myUnLock();
                }
    
            }, "T1").start();
    
            TimeUnit.SECONDS.sleep(1);
    
            new Thread(() -> {
                lock.myLock();
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.myUnLock();
                }
    
            }, "T2").start();
    
        }
    }

运行结果如下：  
![在这里插入图片描述][c751cca3477f418d89845d7f80ea8c32.png]

### 10.4 死锁 ###

> 什么是死锁？

![在这里插入图片描述][796d2a91041d4119b04fc90ef909c881.png]  
  
死锁测试：

public class DeadLockDemo {
        public static void main(String[] args) {
            String lockA = "lockA";
            String lockB = "lockB";
    
            new Thread(new MyThread(lockA, lockB),"T1").start();
            new Thread(new MyThread(lockB, lockA),"T2").start();
        }
    }
    
    class MyThread implements Runnable {
        private String lockA;
        private String lockB;
    
        public MyThread(String lockA, String lockB) {
            this.lockA = lockA;
            this.lockB = lockB;
        }
    
        @Override
        public void run() {
            synchronized (lockA) {
                System.out.println(Thread.currentThread().getName() + "lock:" + lockA + "get " + lockB);
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockB) {
                    System.out.println(Thread.currentThread().getName() + "lock:" + lockB + "get " + lockA);
                }
            }
        }
    }

![在这里插入图片描述][071423d2e90a4025911205bb4275f13c.png]

> 解决问题

1、使用 `jps -l` 定位进程号  
![在这里插入图片描述][3b63559484f5439f805663ded62a61e3.png_pic_center]  
  
2、使用 `jstack进程号` 找到死锁问题  
![在这里插入图片描述][a2c11fcd33c34a5bbede95e2cf734f72.png]  
  
排查问题：  
1、日志  
2、堆栈信息

**创作不易，如果有帮助到你，请给题解点个赞和收藏，让更多的人看到！！！**  
**关注博主不迷路，内容持续更新中。**

[3716360362f14725851436d24ea1a015.png_pic_center]: https://img-blog.csdnimg.cn/3716360362f14725851436d24ea1a015.png#pic_center
[e6bba52a1ff04278979b8f277f639ebf.png_pic_center]: https://img-blog.csdnimg.cn/e6bba52a1ff04278979b8f277f639ebf.png#pic_center
[de52bed529a047db99298102287cee25.png]: https://img-blog.csdnimg.cn/de52bed529a047db99298102287cee25.png
[1dbe56be4e2349af8e9b06ab65eb97bf.png_pic_center]: https://img-blog.csdnimg.cn/1dbe56be4e2349af8e9b06ab65eb97bf.png#pic_center
[64d510e6976e4367bf6075562cda3f71.png_pic_center]: https://img-blog.csdnimg.cn/64d510e6976e4367bf6075562cda3f71.png#pic_center
[5bd3b46d2eef4a36b47ad12a7fc52cfe.png]: https://img-blog.csdnimg.cn/5bd3b46d2eef4a36b47ad12a7fc52cfe.png
[36dd379a504e49ed8e18727e8053878c.png]: https://img-blog.csdnimg.cn/36dd379a504e49ed8e18727e8053878c.png
[1a023f96e23f4f8a8051427018367906.png]: https://img-blog.csdnimg.cn/1a023f96e23f4f8a8051427018367906.png
[37259540d5034127949a08747886a4de.png]: https://img-blog.csdnimg.cn/37259540d5034127949a08747886a4de.png
[12ab6a3caeaa46ef8213de375c60e80f.png_pic_center]: https://img-blog.csdnimg.cn/12ab6a3caeaa46ef8213de375c60e80f.png#pic_center
[3b360d20df2d4ccd807b96a7ab9a34ab.png_pic_center]: https://img-blog.csdnimg.cn/3b360d20df2d4ccd807b96a7ab9a34ab.png#pic_center
[4afe77f36a2e48069599cd5db3f5cdc9.png]: https://img-blog.csdnimg.cn/4afe77f36a2e48069599cd5db3f5cdc9.png
[bbf3487168b947dd9568e22ab929bd64.png]: https://img-blog.csdnimg.cn/bbf3487168b947dd9568e22ab929bd64.png
[837bc84b1d9c4819bd091e0cf722b80a.png_pic_center]: https://img-blog.csdnimg.cn/837bc84b1d9c4819bd091e0cf722b80a.png#pic_center
[2d12ee2f19684a3a9a6f3ba458b503c6.png]: https://img-blog.csdnimg.cn/2d12ee2f19684a3a9a6f3ba458b503c6.png
[85704f5295c941ecabf10ea1e7f3866b.png_pic_center]: https://img-blog.csdnimg.cn/85704f5295c941ecabf10ea1e7f3866b.png#pic_center
[67de19d7b9cc4cd595e4ceb856c897ad.png_pic_center]: https://img-blog.csdnimg.cn/67de19d7b9cc4cd595e4ceb856c897ad.png#pic_center
[63b2bd39db56464d84ef72ae9e73051c.png_pic_center]: https://img-blog.csdnimg.cn/63b2bd39db56464d84ef72ae9e73051c.png#pic_center
[c4926af4aa9e48d7a1f668b0e0aa34be.png]: https://img-blog.csdnimg.cn/c4926af4aa9e48d7a1f668b0e0aa34be.png
[2ce6fb45f0434ba1b2066563cf1a6088.png]: https://img-blog.csdnimg.cn/2ce6fb45f0434ba1b2066563cf1a6088.png
[8d0c52e408f842ee926ac1279d5c5331.png]: https://img-blog.csdnimg.cn/8d0c52e408f842ee926ac1279d5c5331.png
[01a8684d2c7e4f9f97e361164d163af2.png]: https://img-blog.csdnimg.cn/01a8684d2c7e4f9f97e361164d163af2.png
[fda83c1d10f14f7e8eb10a25f3973818.png]: https://img-blog.csdnimg.cn/fda83c1d10f14f7e8eb10a25f3973818.png
[04d5d5c570614568ba0f25f6628d0a71.png]: https://img-blog.csdnimg.cn/04d5d5c570614568ba0f25f6628d0a71.png
[3ed2200faedd4a7695984d42f78cf534.png]: https://img-blog.csdnimg.cn/3ed2200faedd4a7695984d42f78cf534.png
[3bd76a7bd9cf42d6ade30e421ea5b640.png]: https://img-blog.csdnimg.cn/3bd76a7bd9cf42d6ade30e421ea5b640.png
[9f9de97c60b549af95cb61520fb49c5c.png]: https://img-blog.csdnimg.cn/9f9de97c60b549af95cb61520fb49c5c.png
[c751cca3477f418d89845d7f80ea8c32.png]: https://img-blog.csdnimg.cn/c751cca3477f418d89845d7f80ea8c32.png
[796d2a91041d4119b04fc90ef909c881.png]: https://img-blog.csdnimg.cn/796d2a91041d4119b04fc90ef909c881.png
[071423d2e90a4025911205bb4275f13c.png]: https://img-blog.csdnimg.cn/071423d2e90a4025911205bb4275f13c.png
[3b63559484f5439f805663ded62a61e3.png_pic_center]: https://img-blog.csdnimg.cn/3b63559484f5439f805663ded62a61e3.png#pic_center
[a2c11fcd33c34a5bbede95e2cf734f72.png]: https://img-blog.csdnimg.cn/a2c11fcd33c34a5bbede95e2cf734f72.png