Java SE 多线程并发：锁策略、JUC 与原理

一个线程对于数据的访问，主要存在两种操作：读数据和写数据。

• 两个线程都只是读一个数据，此时并没有线程安全问题。直接并发的读取即可。
• 两个线程都要写一个数据，有线程安全问题。
• 一个线程读另外一个线程写，也有线程安全问题。

读写锁就是把读操作和写操作区分对待。Java 标准库提供了 ReentrantReadWriteLock 类，实现了读写锁。

ReentrantReadWriteLock.ReadLock 类表示一个读锁。这个对象提供了 lock / unlock 方法进行加锁解锁。 ReentrantReadWriteLock.WriteLock 类表示一个写锁。这个对象也提供了 lock / unlock 方法进行加锁解锁。 其中：

• 读加锁和读加锁之间，不互斥。
• 写加锁和写加锁之间，互斥。
• 读加锁和写加锁之间，互斥。

读写锁特别适合于'频繁读，不频繁写'的场景中。

2. 死锁

什么是死锁？ 死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

示例：吃饺子需要酱油和醋。我拿起酱油瓶，对象拿起醋瓶。我让你先把醋给我，你用完了把酱油给我；对象让你先把酱油给我，你用完了把醋给我。如果我们俩彼此之间互不相让，就构成了死锁。 酱油和醋相当于是两把锁，我们两个人就是两个线程。

2.1 哲学家就餐问题

有个桌子，围着一圈哲学家，桌子中间放着一盘意大利面。每个哲学家两两之间，放着一根筷子。

每个哲学家只做两件事：思考人生或者吃面条。思考人生的时候就会放下筷子。吃面条就会拿起左右两边的筷子（先拿起左边，再拿起右边）。

如果哲学家发现筷子拿不起来了，就会阻塞等待。 关键点：如果 5 位哲学家同时拿起左手边的筷子时，然后再尝试拿右手的筷子，就会发现右手的筷子都被占用了。由于哲学家们互不相让，这个时候就形成了死锁。

死锁是一种严重的 BUG，导致一个程序的线程'卡死'，无法正常工作！

2.2 形成死锁的必要条件

死锁产生的四个必要条件：

1. 互斥使用，即当资源被一个线程使用 (占有) 时，别的线程不能使用。
2. 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
3. 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
4. 循环等待，即存在一个等待队列：P1 占有 P2 的资源，P2 占有 P3 的资源，P3 占有 P1 的资源。这样就形成了一个等待环路。

当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

2.3 如何避免死锁

破坏循环等待 最常用的一种死锁阻止技术就是锁排序。假设有 N 个线程尝试获取 M 把锁，就可以针对 M 把锁进行编号 (1, 2, 3…M)。 N 个线程尝试获取锁的时候，都按照固定的按编号由小到大的顺序来获取锁。这样就可以避免环路等待。

可能产生循环等待死锁的代码：

public class Test {
    private static Object locker1 = new Object();
    private static Object locker2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                synchronized (locker2) {
                    System.out.println("this is thread t1");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (locker2) {
                synchronized (locker1) {
                    System.out.println("this is thread t2");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

不会产生循环等待的代码：

public class Test {
    private static Object locker1 = new Object();
    private static Object locker2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                synchronized (locker2) {
                    System.out.println("this is thread t1");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (locker1) {
                synchronized (locker2) {
                    System.out.println("this is thread t2");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

3. JUC(java.util.concurrent) 的常见类

3.1 Callable 接口

Callable 是一个 interface。 相当于把线程封装了一个'返回值'。方便我们借助多线程的方式计算结果。

代码示例：创建线程计算 1 + 2 + 3 + … + 1000，使用 Callable 版本。

1. 创建一个匿名内部类，实现 Callable 接口。Callable 带有泛型参数。泛型参数表示返回值的类型。
2. 重写 Callable 的 call 方法，完成累加的过程。直接通过返回值返回计算结果。
3. 把 callable 实例使用 FutureTask 包装一下。
4. 创建线程，线程的构造方法传入 FutureTask。此时新线程就会执行 FutureTask 内部的 Callable 的 call 方法，完成计算。计算结果就放到了 FutureTask 对象中。
5. 在主线程中调用 futureTask.get() 能够阻塞等待新线程计算完毕。并获取到 FutureTask 中的结果。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int result = 0;
                for (int i = 0; i <= 1_000; i++) {
                    result += i;
                }
                return result;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
        System.out.println(futureTask.get());
    }
}
// 输出：500500

理解 Callable Callable 和 Runnable 相对，都是描述一个'任务'。Callable 描述的是带有返回值的任务，Runnable 描述的是不带返回值的任务。 Callable 通常需要搭配 FutureTask 来使用。FutureTask 用来保存 Callable 的返回结果。因为 Callable 往往是在另一个线程中执行的，啥时候执行完并不确定。FutureTask 就可以负责这个等待结果出来的工作。

理解 FutureTask 想象去吃麻辣烫。当餐点好后，后厨就开始做了。同时前台会给你一张'小票'。这个小票就是 FutureTask。后面我们可以随时凭这张小票去查看自己的这份麻辣烫做出来了没。

3.2 ReentrantLock

可重入互斥锁。 和 synchronized 定位类似，都是用来实现互斥效果，保证线程安全。

ReentrantLock 的用法：

• lock(): 加锁，如果获取不到锁就死等。
• trylock(超时时间): 加锁，如果获取不到锁，等待一定的时间之后就放弃加锁。
• unlock(): 解锁

ReentrantLock 和 synchronized 的区别：

1. synchronized 是一个关键字，是 JVM 内部实现的，ReentrantLock 是标准库的一个类，在 JVM 外实现的 (基于 Java 实现)。
2. synchronized 使用时不需要手动释放锁。ReentrantLock 使用时需要手动释放。使用起来更灵活，但是也容易遗漏 unlock。
3. synchronized 在申请锁失败时，会死等。ReentrantLock 可以通过 trylock 的方式等待一段时间就放弃。
4. synchronized 是非公平锁，ReentrantLock 默认是非公平锁。可以通过构造方法传入一个 true 开启公平锁模式。
5. 更强大的唤醒机制。synchronized 是通过 Object 的 wait / notify 实现等待 - 唤醒。每次唤醒的是一个随机等待的线程。ReentrantLock 搭配 Condition 类实现等待 - 唤醒，可以更精确控制唤醒某个指定的线程。

如何选择使用哪个锁？

1. 锁竞争不激烈的时候，使用 synchronized，效率更高，自动释放更方便。
2. 锁竞争激烈的时候，使用 ReentrantLock，搭配 trylock 更灵活控制加锁的行为，而不是死等。
3. 如果需要使用公平锁，使用 ReentrantLock。

3.3 原子类

原子类内部用的是 CAS 实现，所以性能要比加锁实现 i++ 高很多。原子类有以下几个:

1. AtomicBoolean
2. AtomicInteger
3. AtomicIntegerArray
4. AtomicLong
5. AtomicReference
6. AtomicStampedReference

以 AtomicInteger 举例，常见方法有:

addAndGet(int delta); // i += delta;
decrementAndGet();    // --i;
getAndDecrement();    // i--;
incrementAndGet();    // ++i;
getAndIncrement();    // i++;

3.4 信号量 Semaphore

信号量，用来表示'可用资源的个数'。本质上就是一个计数器。

示例：可以把信号量想象成是停车场的展示牌：当前有车位 100 个。表示有 100 个可用资源。 当有车开进去的时候，就相当于申请一个可用资源，可用车位就 -1 (这个称为信号量的 P 操作，P 是荷兰语单词首字母)。 当有车开出来的时候，就相当于释放一个可用资源，可用车位就 +1 (这个称为信号量的 V 操作，V 是荷兰语单词首字母)。 如果计数器的值已经为 0 了，还尝试申请资源，就会阻塞等待，直到有其他线程释放资源。

Semaphore 的 PV 操作中的加减计数器操作都是原子的，可以在多线程环境下直接使用。

代码示例：

import java.util.concurrent.Semaphore;

public class Test {
    public static void main(String[] args) {
        // 创建 Semaphore 示例，初始化为 4，表示有 4 个可用资源。
        // acquire 方法表示申请资源 (P 操作), release 方法表示释放资源 (V 操作)
        // 创建 20 个线程，每个线程都尝试申请资源，sleep 1 秒之后，释放资源。观察程序的执行效果。
        Semaphore semaphore = new Semaphore(4);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("apply");
                try {
                    semaphore.acquire();
                    System.out.println("successful");
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                semaphore.release();
                System.out.println("release");
            }
        };
        for (int i = 0; i < 20; i++) {
            Thread t = new Thread(runnable);
            t.start();
        }
    }
}

3.5 CountDownLatch

同时等待 N 个任务执行结束

例如：好像跑步比赛，10 个选手依次就位，哨声响才同时出发；所有选手都通过终点，才能公布成绩。

代码示例：

1. 构造 CountDownLatch 实例，初始化 10 表示有 10 个任务需要完成。
2. 每个任务执行完毕，都调用 countDown()。在 CountDownLatch 内部的计数器同时自减。
3. 主线程中使用 latch.await()；阻塞等待所有任务执行完毕。相当于计数器为 0 了。

import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count = new CountDownLatch(10);
        Random random = new Random();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(random.nextInt(5000));
                    count.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(runnable);
            t.start();
        }
        // 必须等到 10 人全部回来
        count.await();
        System.out.println("game is over");
    }
}

4. synchronized 原理

首先，我们总结一下 synchronized 锁的基本特性：

1. 开始时是乐观锁，如果锁冲突频繁，就转换为悲观锁。
2. 开始是轻量级锁实现，如果锁被持有的时间较长，就转换成重量级锁。
3. 实现轻量级锁的时候大概率用到自旋锁策略。
4. 是一种不公平锁。
5. 是一种可重入锁。
6. 不是读写锁。

4.1 加锁工作过程

JVM 将 synchronized 锁分为无锁、偏向锁、轻量级锁、重量级锁 状态。会根据情况，进行依次升级。

1. 偏向锁 第一个尝试加锁的线程，优先进入偏向锁状态。 偏向锁不是真的'加锁'，只是给对象头中做一个'偏向锁的标记'，记录这个锁属于哪个线程。如果后续没有其他线程来竞争该锁，那么就不用进行其他同步操作了 (避免了加锁解锁的开销)，如果后续有其他线程来竞争该锁 (刚才已经在锁对象中记录了当前锁属于哪个线程了，很容易识别当前申请锁的线程是不是之前记录的线程)，那就取消原来的偏向锁状态，进入一般的轻量级锁状态。 偏向锁本质上相当于'延迟加锁'。能不加锁就不加锁，尽量来避免不必要的加锁开销。但是该做的标记还是得做的，否则无法区分何时需要真正加锁。

2. 轻量级锁 随着其他线程进入竞争，偏向锁状态被消除，进入轻量级锁状态 (自适应的自旋锁)。

3. 重量级锁 如果竞争进一步激烈，自旋不能快速获取到锁状态，就会膨胀为重量级锁。

4.2 其他的优化操作

1. 锁消除 有些应用程序的代码中，用到了 synchronized，但其实没有在多线程环境下，编译器+JVM 会判断锁是否可消除。如果可以，就直接消除，避免白白浪费了一些资源开销。

2. 锁粗化 一段逻辑中如果出现多次加锁解锁，编译器+JVM 会自动进行锁的粗化。

示例：滑稽老哥当了领导，给下属交代工作任务。 方式一：打电话，交代任务 1，挂电话。打电话，交代任务 2，挂电话。打电话，交代任务 3，挂电话。 方式二：打电话，交代任务 1，任务 2，任务 3，挂电话。 明显方式二的效率更高。

5. CAS

CAS: 全称 Compare and swap，字面意思：'比较并交换'，一个 CAS 涉及到以下操作：

我们假设内存中的原数据 V，旧的预期值 A，需要修改的新值 B。

1. 比较 A 与 V 是否相等。（比较）
2. 如果比较相等，将 B 写入 V。（交换）
3. 返回操作是否成功

5.1 CAS 的 ABA 问题

ABA 问题就好比，我们买一个手机，无法判定这个手机是刚出厂的新手机，还是别人用旧了，又翻新过的手机。