Java 메모리 모델에 대한 심층 분석: 잠금

잠금 해제-관계 이전에 설정된 것을 가져옵니다잠금은 Java 동시 프로그래밍에서 가장 중요한 동기화 메커니즘입니다. 잠금은 임계 섹션의 상호 배타적 실행을 허용하는 것 외에도 잠금을 해제하는 스레드가 동일한 잠금을 획득하는 스레드에 메시지를 보낼 수 있도록 허용합니다. 다음은 잠금 해제-취득에 대한 샘플 코드입니다. 스레드 A가writer() 메서드를 실행하고 스레드 B가 reader() 메서드를 실행한다고 가정합니다. 이전 발생 규칙에 따르면 이 프로세스에 포함된 이전 발생 관계는 두 가지 범주로 나눌 수 있습니다. 프로그램 순서 규칙에 따르면 1은 2 이전에 발생하고 2는 3 이전에 발생하며 5는 5 이전에 발생합니다. 6. 모니터 잠금 규칙에 따르면 3이 4보다 먼저 발생합니다. 이전에 발생하는 전이성에 따르면 2는 5보다 먼저 발생합니다. 위의 발생 이전 관계를 그래픽으로 표현하면 다음과 같습니다. 위 그림에서 각 화살표로 연결된 두 노드는 발생 이전을 나타냅니다. 관계. 검은색 화살표는 프로그램 순서 규칙을 나타내고, 주황색 화살표는 모니터 잠금 규칙을 나타내고, 파란색 화살표는 이러한 규칙을 결합하여 제공되는 사전 발생 보장을 나타냅니다. 위 그림은 스레드 A가 잠금을 해제한 후 스레드 B가 동일한 잠금을 획득하는 것을 보여줍니다. 위 그림에서 2는 5보다 먼저 발생합니다. 따라서 잠금을 해제하기 전에 스레드 A에 표시되는 모든 공유 변수는 스레드 B가 동일한 잠금을 획득한 후에 즉시 스레드 B에 표시됩니다. 잠금 해제 및 획득의 메모리 의미스레드가 잠금을 해제하면 JMM은 스레드에 해당하는 로컬 메모리의 공유 변수를 주 메모리로 새로 고칩니다. 위의 MonitorExample 프로그램을 예로 들면, 스레드 A가 잠금을 해제한 후 공유 데이터의 상태 다이어그램은 다음과 같습니다. 스레드가 잠금을 획득하면 JMM 내부 설정이 유효하지 않습니다. 결과적으로 모니터에 의해 보호되는 임계 섹션 코드는 주 메모리에서 공유 변수를 읽어야 합니다. 다음은 잠금 획득 상태의 개략도입니다. 잠금 해제-획득의 메모리 의미와 휘발성 쓰기-읽기의 메모리 의미를 비교하면 다음과 같습니다. 잠금 해제와 휘발성 쓰기는 서로 관련되어 있습니다. 동일한 메모리 잠금 획득과 휘발성 읽기는 동일한 메모리 의미를 갖습니다. 다음은 잠금 해제 및 잠금 획득의 메모리 의미를 요약한 것입니다. 스레드 A는 본질적으로 공유 변수 수정에 대한 (스레드 A) 메시지를 발행합니다. 스레드 B는 본질적으로 잠금을 획득합니다. 본질적으로 스레드 B는 이전 스레드에서 보낸 메시지를 받습니다(잠금을 해제하기 전에 공유 변수 수정). 스레드 A가 잠금을 해제한 후 스레드 B가 잠금을 획득합니다. 이 프로세스는 본질적으로 스레드 A가 주 메모리를 통해 스레드 B에 메시지를 보내는 것입니다. 잠금 메모리 의미론의 구현이 기사에서는 ReentrantLock의 소스 코드를 사용하여 잠금 메모리 의미론의 구체적인 구현 메커니즘을 분석합니다. 아래 샘플 코드를 참고하세요. ReentrantLock에서 lock() 메서드를 호출하여 잠금을 획득하고, Unlock() 메서드를 호출하여 잠금을 해제합니다. ReentrantLock의 구현은 Java 동기화 프레임워크 AbstractQueuedSynchronizer(이 문서에서는 AQS라고 함)를 사용합니다. AQS는 동기화 상태를 유지하기 위해 정수 휘발성 변수(state)를 사용합니다. 우리는 이 휘발성 변수가 ReentrantLock 메모리 의미론 구현의 핵심이라는 것을 곧 알게 될 것입니다. ReentrantLock의 클래스 다이어그램은 다음과 같습니다(이 글과 관련된 부분만 그렸습니다). ReentrantLock은 공정한 잠금과 불공정한 잠금으로 나누어 먼저 분석합니다. 잠그다. Fair Lock 사용 시 잠금 메서드 lock()의 Trace를 호출하는 메서드는 다음과 같습니다. ReentrantLock : lock()FairSync : lock()AbstractQueuedSynchronizer : acquire(int arg)ReentrantLock: tryAcquire(int acquires)실제로 잠금은 4단계에서 시작됩니다. 다음은 이 메서드의 소스 코드입니다. 에서 볼 수 있듯이 위의 소스 코드에서 잠금 방법은 먼저 휘발성 변수 상태를 읽습니다. 공정 잠금 사용 시 잠금 해제 메서드 Unlock()의 추적을 호출하는 메서드는 다음과 같습니다. ReentrantLock: Unlock()AbstractQueuedSynchronizer: release(int arg)Sync: tryRelease (int releases )3단계에서 잠금을 해제합니다. 이 메서드의 소스 코드는 다음과 같습니다.

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);           //释放锁的最后，写volatile变量state
    return free;
}

从上面的源代码我们可以看出，在释放锁的最后写volatile变量state。

公平锁在释放锁的最后写volatile变量state；在获取锁时首先读这个volatile变量。根据volatile的happens-before规则，释放锁的线程在写volatile变量之前可见的共享变量，在获取锁的线程读取同一个volatile变量后将立即变的对获取锁的线程可见。

现在我们分析非公平锁的内存语义的实现。

非公平锁的释放和公平锁完全一样，所以这里仅仅分析非公平锁的获取。

使用公平锁时，加锁方法lock()的方法调用轨迹如下：
ReentrantLock : lock()
NonfairSync : lock()
AbstractQueuedSynchronizer : compareAndSetState(int expect, int update)

在第3步真正开始加锁，下面是该方法的源代码：

protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

该方法以原子操作的方式更新state变量，本文把java的compareAndSet()方法调用简称为CAS。JDK文档对该方法的说明如下：如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值。此操作具有 volatile 读和写的内存语义。

这里我们分别从编译器和处理器的角度来分析,CAS如何同时具有volatile读和volatile写的内存语义。

前文我们提到过，编译器不会对volatile读与volatile读后面的任意内存操作重排序；编译器不会对volatile写与volatile写前面的任意内存操作重排序。组合这两个条件，意味着为了同时实现volatile读和volatile写的内存语义，编译器不能对CAS与CAS前面和后面的任意内存操作重排序。

下面我们来分析在常见的intel x86处理器中，CAS是如何同时具有volatile读和volatile写的内存语义的。

下面是sun.misc.Unsafe类的compareAndSwapInt()方法的源代码：

public final native boolean compareAndSwapInt(Object o, long offset,
                                              int expected,
                                              int x);

可以看到这是个本地方法调用。这个本地方法在openjdk中依次调用的c++代码为：unsafe.cpp，atomic.cpp和atomicwindowsx86.inline.hpp。这个本地方法的最终实现在openjdk的如下位置：openjdk-7-fcs-src-b147-27jun2011\openjdk\hotspot\src\oscpu\windowsx86\vm\ atomicwindowsx86.inline.hpp（对应于windows操作系统，X86处理器）。下面是对应于intel x86处理器的源代码的片段：

// Adding a lock prefix to an instruction on MP machine
// VC++ doesn't like the lock prefix to be on a single line
// so we can't insert a label after the lock prefix.
// By emitting a lock prefix, we can define a label after it.
#define LOCK_IF_MP(mp) __asm cmp mp, 0  \
                       __asm je L0      \
                       __asm _emit 0xF0 \
                       __asm L0:

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  // alternative for InterlockedCompareExchange
  int mp = os::is_MP();
  __asm {
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    LOCK_IF_MP(mp)
    cmpxchg dword ptr [edx], ecx
  }
}

如上面源代码所示，程序会根据当前处理器的类型来决定是否为cmpxchg指令添加lock前缀。如果程序是在多处理器上运行，就为cmpxchg指令加上lock前缀（lock cmpxchg）。反之，如果程序是在单处理器上运行，就省略lock前缀（单处理器自身会维护单处理器内的顺序一致性，不需要lock前缀提供的内存屏障效果）。

intel的手册对lock前缀的说明如下：
确保对内存的读-改-写操作原子执行。在Pentium及Pentium之前的处理器中，带有lock前缀的指令在执行期间会锁住总线，使得其他处理器暂时无法通过总线访问内存。很显然，这会带来昂贵的开销。从Pentium 4，Intel Xeon及P6处理器开始，intel在原有总线锁的基础上做了一个很有意义的优化：如果要访问的内存区域（area of memory）在lock前缀指令执行期间已经在处理器内部的缓存中被锁定（即包含该内存区域的缓存行当前处于独占或以修改状态），并且该内存区域被完全包含在单个缓存行（cache line）中，那么处理器将直接执行该指令。由于在指令执行期间该缓存行会一直被锁定，其它处理器无法读/写该指令要访问的内存区域，因此能保证指令执行的原子性。这个操作过程叫做缓存锁定（cache locking），缓存锁定将大大降低lock前缀指令的执行开销，但是当多处理器之间的竞争程度很高或者指令访问的内存地址未对齐时，仍然会锁住总线。
禁止该指令与之前和之后的读和写指令重排序。
把写缓冲区中的所有数据刷新到内存中。

上面的第2点和第3点所具有的内存屏障效果，足以同时实现volatile读和volatile写的内存语义。

经过上面的这些分析，现在我们终于能明白为什么JDK文档说CAS同时具有volatile读和volatile写的内存语义了。

现在对公平锁和非公平锁的内存语义做个总结：
公平锁和非公平锁释放时，最后都要写一个volatile变量state。
公平锁获取时，首先会去读这个volatile变量。
非公平锁获取时，首先会用CAS更新这个volatile变量,这个操作同时具有volatile读和volatile写的内存语义。

从本文对ReentrantLock的分析可以看出，锁释放-获取的内存语义的实现至少有下面两种方式：
利用volatile变量的写-读所具有的内存语义。
利用CAS所附带的volatile读和volatile写的内存语义。

concurrent包的实现

由于java的CAS同时具有 volatile 读和volatile写的内存语义，因此Java线程之间的通信现在有了下面四种方式：
A线程写volatile变量，随后B线程读这个volatile变量。
A线程写volatile变量，随后B线程用CAS更新这个volatile变量。
A线程用CAS更新一个volatile变量，随后B线程用CAS更新这个volatile变量。
A线程用CAS更新一个volatile变量，随后B线程读这个volatile变量。

Java的CAS会使用现代处理器上提供的高效机器级别原子指令，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键（从本质上来说，能够支持原子性读-改-写指令的计算机器，是顺序计算图灵机的异步等价机器，因此任何现代的多处理器都会去支持某种能对内存执行原子性读-改-写操作的原子指令）。同时，volatile变量的读/写和CAS可以实现线程之间的通信。把这些特性整合在一起，就形成了整个concurrent包得以实现的基石。如果我们仔细分析concurrent包的源代码实现，会发现一个通用化的实现模式：
首先，声明共享变量为volatile；
然后，使用CAS的原子条件更新来实现线程之间的同步；
同时，配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信。

AQS，非阻塞数据结构和原子变量类（java.util.concurrent.atomic包中的类），这些concurrent包中的基础类都是使用这种模式来实现的，而concurrent包中的高层类又是依赖于这些基础类来实现的。从整体来看，concurrent包的实现示意图如下：

 以上就是Java内存模型深度解析：锁的内容，更多相关内容请关注PHP中文网（www.php.cn）！