锁的内存语义

Java 并发

发布日期: 2021-10-24

更新日期: 2022-06-19

文章字数: 1.6k

阅读时长: 6 分

阅读次数:

1、锁的释放-获取建立的happens-before关系

锁是并发编程中最重要的同步机制。锁除了让临界区互斥执行外，还可以让释放锁的线程向获取同一个锁的线程发送消息。

下面是锁释放-获取的示例代码：

class MonitorExample {
    int a = 0;
    public synchronized void writer() { // 1
        a++; // 2
    } // 3
    public synchronized void reader() { // 4
        int i = a; // 5
        ……
    } // 6
}

假设线程A执行write（）方法，随后线程B执行reader（）方法。根据 Happens-Before 规则，这个过程包含的Happens-Before 关系可以分为3类：

根据程序次序规则，1happens-before 2，2 happens-before 3，4 happens-before 5， 5 happens-before 6。
根据监视器锁规则，3 happens-before 4。
根据 happens-before 的传递性，2 happens-before 5。

上述happens-before关系的图形化表现形式如图所示：

在图中，每一个箭头连接的两个节点，代表了一个happens-before关系。黑色箭头表示程序顺序规则；橙色箭头表示监视器锁规则；蓝色箭头表示组合这些规则后提供的happens-before保证。

图中表示在线程A释放了锁之后，随后线程B获取同一个锁，在图中2 happens-before 5，因为线程A在释放锁之前所有可见的共享变量，在线程B获取同一个锁之后，将立即变得对B线程可见。

2、锁的释放和获取的内存语义

当线程释放锁时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。以上面的MonitorExample程序为例，A线程释放锁后，共享数据的状态示意图如下图所示：

当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量，下图是锁的状态示意图：

对比锁释放-获取的内存语义与volatile写-读的内存语义可以看出：锁释放与volatile写有相同的内存语义；锁获取与volatile读有相同的内存语义。

下面对锁释放和锁获取的内存语义做个总结：

线程A释放一个锁，实质上是线程A向接下来将要获取这个锁的某个线程发出了（线程A对共享变量所做修改的）消息。
线程B获取一个锁，实质上是线程B接收了之前某个线程B发出的（在释放这个锁之前对共享变量所做的修改）消息。
线程A释放锁，随后线程B获取这个锁，这个过程实质上是线程A通过主内存向线程B发送消息。

3、锁内存语义的实现

下面以 ReentrantLock 的源代码，来分析锁内存语义的具体实现机制：

class ReentrantLockExample {
    int a = 0;
    ReentrantLock lock = new ReentrantLock();
    public void writer() {
        lock.lock(); // 获取锁
        try {
            a++;
        } f inally {
            lock.unlock(); // 释放锁
        }
    }
    public void reader () {
        lock.lock(); // 获取锁
        try {
            int i = a;
            ……
        } f inally {
            lock.unlock(); //释放锁
        }
    }
}

在 ReentrantLock 中，调用 lock（）方法获取锁，调用 unlock（）方法释放锁。

ReentrantLock 的实现依赖于 Java 同步器框架 AbstractQueueSynchronized (AQS) 。AQS 使用一个整形的volatile 变量（state）来维护同步状态，这个变量是ReentrantLock 内存语义的关键。

下图是 ReentrantLoc 的类图：

ReentrantLock 分为公平锁和非公平锁，首先分析公平锁：

使用公平锁时，加锁方法lock()调用轨迹如下：

1）ReentrantLock：lock()

2）FairSync:lock()。

3）AbstractQueuedSynchronizer:acquire(int arg)。

4）ReentrantLock:tryAcquire(int acquires)。

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

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState(); // 获取锁的开始，首先读volatile变量state
    if (c == 0) {
        if (isFirst(current) &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

从上面的源代码中可以看出，加锁方法首先读 volatile 变量 state。

在使用公平锁时，解锁方法 unlock（）调用轨迹如下：

1）ReentrantLock:unlock()。
2）AbstractQueuedSynchronizer:release(int arg)。
3）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变量后将立即变得对获取锁的线程可见。

现在我们来分析非公平锁的内存语义的实现。非公平锁的释放和公平锁完全一样，这里仅仅分析非公平锁的获取。使用非公平锁时，加锁方法lock（）调用轨迹如下。

1）ReentrantLock:lock()。
2）NonfairSync:lock()。
3）AbstractQueuedSynchronizer:compareAndSetState(int expect,int update)。

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

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

该方法以原子操作的方式更新state变量，称为CAS，CAS同时具有volatile读和volatile写的内存语义。编译器不能对CAS与CAS前面和后面的任意内存操作重排序。例如在 intel X86 处理器中，CAS 的底层就是使用的 cmpxchg 指令，如果程序是在多处理器上运行，就位cmpxchg指令加上lock前缀（Lock Cmpxch），反之，如果程序是在单处理器上运行，就省略lock前缀（单处理器自身会维护单处理器内的顺序一致性，不需要lock前缀提供的内存屏障效果）。

公平锁和非公平锁的内存语义总结：