Java多线程（十五）---锁的内存语义

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

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执行writer()方法，随后线程B执行reader()方法。

• 根据happens-before规则，这个过程包含的happens-before关系可以分为3类。
• 1）根据程序次序规则，1 happens-before 2,2 happens-before 3;4 happens-before 5,5 happens-before 6。
• 2）根据监视器锁规则，3 happens-before 4。
• 3）根据happens-before的传递性，2 happens-before 5

qq_pic_merged_1533872844497.jpg

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

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

• 锁释放与volatile写有相同的内存语义；锁获取与volatile读有相同的内存语义。

• 线程A释放一个锁，实质上是线程A向接下来将要获取这个锁的某个线程发出了（线程A对共享变量所做修改的）消息。

• 线程B获取一个锁，实质上是线程B接收了之前某个线程发出的（在释放这个锁之前对共享变量所做修改的）消息。

• 线程A释放锁，随后线程B获取这个锁，这个过程实质上是线程A通过主内存向线程B发送消息

3锁内存语义的实现

本节借助RenntrantLock的源代码分析

• ReentrantLock的实现依赖于Java同步器框架AbstractQueuedSynchronizer（本文简称之为AQS）。AQS使用一个整型的volatile变量（命名为state）来维护同步状态

3.1 公平锁

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();　 // 释放锁
        }
    }
}

3.1.1 加锁

• 使用公平锁时，加锁方法lock()调用轨迹如下。
• 1）ReentrantLock:lock()。
• 2）FairSync:lock()。
• 3）AbstractQueuedSynchronizer:acquire(int arg)。
• 4）ReentrantLock:tryAcquire(int acquires)。

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

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。

3.1.2 解锁

• 在使用公平锁时，解锁方法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。

3.1.3 总结

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

3.2 非公平锁

3.2.1解锁

非公平锁解锁和公平锁解锁完全一样。

3.2.2 加锁

• 使用非公平锁时，加锁方法lock()调用轨迹如下。
• 1）ReentrantLock:lock()。
• 2）NonfairSync:lock()。
• 3）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写前面的任意内存操作重排序。

3.3 总结

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

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

4 concurrent包的实现

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

实现的基石

• Java的CAS会使用现代处理器上提供的高效机器级别的原子指令，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键。
• 同时，volatile变量的读/写和CAS可以实现线程之间的通信。
• 把这些特性整合在一起，就形成了整个concurrent包得以实现的基石。

concurrent包的源代码实现，一个通用化的实现模式。

• 首先，声明共享变量为volatile。
• 然后，使用CAS的原子条件更新来实现线程之间的同步。
• 同时，配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信。
• AQS，非阻塞数据结构和原子变量类（java.util.concurrent.atomic包中的类），这些concurrent包中的基础类都是使用这种模式来实现的

concurrent包的实现示意图：

qq_pic_merged_1534216641535.jpg

参考

《java并发编程的艺术》