秋招Java后端开发冲刺——并发篇2（JMM与锁机制）

本文对Java的内存管理模型、volatile关键字和锁机制进行详细阐述，包括synchronized关键字、Lock接口及其实现类ReentrantLock、AQS等的实现原理和常见方法。

一、JMM（Java内存模型）

1. 介绍
JMM定义了共享内存中多线程程序读写操作的行为规范，通过这些规则来规范对内存的读写操作从而保证指令的正确性。
2. 模型

• JMM把内存分为两块，一块是私有线程的工作区域（工作内存），一块是所有线程的共享区域（主内存）
• 线程跟线程之间是相互隔离，线程跟线程交互需要通过主内存

二、Volatile关键字

1. 介绍

• Volatile关键字主要用于修饰成员变量（实例变量或类变量），使得对该变量的读写操作直接与主内存交互，而不是通过线程本地的工作内存进行缓存。
• Volatile关键字提供了一种轻量级的同步机制，用于保证多线程环境下数据的可见性（但不能保证数据的原子性，Synchronized关键字既保证可见性，又保证原子性）

2. Volatile禁止指令重排
（1）指令重排

指令重排是一种编译器和处理器优化技术，它改变指令执行的顺序，以提高性能。在单线程环境下，这种优化不会影响程序的正确性。但是在多线程环境下，指令重排可能导致意想不到的结果，破坏程序的正确性。

（2）Volatile如何禁止指令重排

• 通过在读写 volatile 变量时插入内存屏障（Memory Barriers）来实现
  • 写屏障（Write Barrier）：确保在写 volatile 变量之前的所有写操作在内存中完成。
  • 读屏障（Read Barrier）：确保在读 volatile 变量之后的所有读操作在内存中完成
• volatile关键字一般加在写变量最后一个，读变量第一个。

class Example {
    private volatile boolean flag = false;
    private int a = 0;

    public void writer() {
        a = 1;           // 1
        flag = true;     // 2
    }

    public void reader() {
        if (flag) {      // 3
            int i = a;   // 4
        }
    }
}

上述示例中：

• 在writer方法中，写入a = 1（1）操作不能被重排序到写入flag = true（2）之后。因为flag是volatile，在写flag的时候会插入一个StoreStore屏障，确保在flag被写入之前，所有之前的写操作都完成了。
• 在reader方法中，读取flag（3）操作不能被重排序到读取a（4）之前。因为flag是volatile，在读flag的时候会插入一个LoadLoad屏障，确保在flag被读取之后，所有之前的读操作都完成了。

三、锁

1. 悲观锁和乐观锁
（1）悲观锁：认为访问共享资源时一定会发生线程安全问题，因此在访问时必须加锁。
（2）乐观锁：认为访问共享资源时不一定会发生线程安全问题，因此不会加锁，当提交修改的时候去验证对应的资源（也就是数据）是否被其它线程修改即可。
（3）二者区别

2. synchronized 关键字
（1）介绍
synchronized 关键字是一种对象锁，采用互斥的方式让同一时刻至多只有一个线程能持有对象锁。
（2）底层实现原理
① Monitor（对象监视器）

• Monitor（监视器）是一种同步机制，用于管理多线程之间的互斥访问和并发控制。Monitor是JVM提供的，但是是基于c++实现的。
• Monitor的结构
  • Owner:存储当前获取锁的线程的，只能有一个线程可以获取
  • EntryList:关联没有抢到锁的线程，处于Blocked状态的线程
  • WaitSet:关联调用了wait方法的线程，处于Waiting状态的线程

② synchronized关键字实现原理
线程获得锁需要使用对象（锁）关联monitor监视器，即获得monitor的持有权。

（3）使用方法

• 同步方法：当一个线程执行同步方法时，它会自动获得该方法所属对象的锁。其他线程在获得该锁之前无法执行该方法。

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

• 同步块：同步块用于在一个方法内同步部分代码，提供了比同步方法更细粒度的控制。

public class SynchronizedBlockExample {
    private final Object lock = new Object();
    private int count = 0;

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

• 静态同步方法：静态同步方法锁定的是类对象，对于所有该类的实例都有效。

public class StaticSynchronizedExample {
    private static int count = 0;

    public static synchronized void increment() {
        count++;
    }

    public static synchronized int getCount() {
        return count;
    }
}

3. synchronized锁升级

Monitor实现的锁属于重量级锁，因为monitor是使用c++实现的，里面涉及到了用户态和内核态的切换、进程的上下文切换，成本较高，性能比较低。在JDK 1.6引入了两种新型锁机制：偏向锁和轻量级锁。

（1）对象的内存结构

注：填充为8的整数倍是方便字节对齐提高程序运行效率 ，而且对于压缩指针也更加的方便。

（2）轻量级锁
在无竞争的情况下，轻量级锁使用CAS操作来实现锁的获取和释放，提高运行效率。
① 加锁流程

• 在线程栈中创建一个Lock Record，将其obj字段指向锁对象。
• 通过CAS指令将Lock Record的地址存储在对象头的mark word中，如果对象处于无锁状态则修改成功，代表该线程获得了轻量级锁。
• 如果是当前线程已经持有该锁了，代表这是一次锁重入。设置Lock Record第一部分为null，起到了一个重入计数器的作用。（仍需CAS操作）
• 如果CAS修改失败，说明发生了竞争，需要膨胀为重量级锁。

② 解锁过程

• 遍历线程栈,找到所有obj字段等于当前锁对象的Lock Record。
• 如果Lock Record的Mark Word为null，代表这是一次重入，将obj设置为null后continue。
• 如果Lock Record的 Mark Word不为null，则利用CAS指令将对象头的mark word恢复成为无锁状态。如果失败则膨胀为重量级锁。

（3）偏向锁
与轻量级锁不同的是，偏向锁只第一次获得锁时使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后该线程再获取锁时，只需要判断锁对象mark word中是否是自己的线程id即可。

注：轻量级锁和偏向锁都是在没有竞争的情况下使用，一旦发生了竞争会立刻升级为重量级锁。

4. Lock接口：ReentrantLock

Lock接口提供了一种比传统的同步块和方法更灵活的锁机制。Lock 接口有多种实现，其中最常用的是 ReentrantLock。

（1）Lock接口常见实现类

（2）ReentrantLock
① ReentrantLock是一个可重入且独占式的锁，还支持轮询、超时、中断、公平锁和非公平锁等。
② 特点

• 可重入性：一个线程可以多次获得该锁，而不会导致死锁。这意味着同一个线程可以进入锁保护的代码块多次，必须确保在离开代码块时相应的次数解锁。
• 公平性：可以选择公平锁或者非公平锁。公平锁按照线程请求的顺序获取锁，非公平锁则没有这种顺序，可能导致某些线程长时间等待。
• 灵活性：提供了比 synchronized 块更灵活的锁获取方式，如可中断的锁获取、超时的锁获取。

③ 实现原理

• ReentrantLock使用CAS+AQS来实现，使用用一个整数state表示锁的状态，使用一个先进先出的队列（CLH）管理被阻塞的线程。
• 当线程需要获得锁时，使用CAS操作修改锁的状态，修改成功则获得锁；修改失败则加入CLH队列管理。

④ 常用方法

5. synchronized与ReentrantLock的比较

6. AQS（Abstract Queued Synchronizer，抽象队列同步器）
（1）介绍
AQS是Java 并发包 (java.util.concurrent.locks) 中的一个核心框架，是构建各种锁和同步组件的基础框架。
（2）实现原理

• AQS 使用一个 int 类型的变量 state 表示同步状态。
• AQS 内部维护了一个 FIFO 队列，用于管理获取锁失败的线程。线程在争夺锁失败后会被封装成队列节点（Node）并加入到等待队列中。
• 队列中每个节点包含线程引用和状态标志

（3）常用方法

（4）常见实现类