锁的内存语义

众所周知，锁可以让临界区互斥执行，这里将介绍锁的另一个同样重要，但常常被忽视的功能：锁的内存语义

1.锁的释放-获取简历的happens-before关系

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

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。
上述happens-before关系的图形化表现形式如下图

  上图中，每一个箭头连接的两个节点，代表一个happens-before关系。黑色箭头表示程序顺序规则；橙色箭头表示监视器锁规则；蓝色箭头表示组合这些规则后提供的happens-before保证。线程A释放了锁之后，线程B获取同一个锁。因此，线程A在释放锁之前所有可见的共享变量，在线程B获取同一个锁之后，将立刻对线程B可见。

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

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

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

  对比锁释放-获取的内存语义与volatile写-读的内存语义可以看出：锁释放与volatile写有相同的内存语义；锁获取与volatile读有相同的内存语义。
  下面对锁释放和锁获取的内存语义做个总结：
1.线程A释放一个锁，实质上是线程A向接下来将要获取这个锁的某个线程发出了（线程A对共享变量所做的修改）消息。
2.线程B获取一个锁，实质上是线程B接收了之前某个线程发出的（在释放锁之前对共享变量所做的修改）消息。
3.线程A释放锁，随后线程B获取这个锁，这个过程实质上是线程A通过主内存向线程B发送消息。

3.锁内存语义的实现

  本文将借助ReentrantLock源码，来分析锁内存语义的具体实现机制

class ReentrantLockExample {
	int a = 0;

	ReentrantLock lock = new ReentrantLock();
	
	public void writer() {
		lock.lock();			// 获取锁
		try {
			a++;
		} finally {
			lock.unlock();		// 是否锁
		}
	}

	public void reader() {
		lock.lock();			// 获取锁
		try {
			int i = a;
			...
		} finally {
			lock.unlock();		// 释放锁
		}
	}

}

  在ReentrantLock中，调用lock()方法获取锁；调用unlock()方法释放锁。
  ReentrantLok的实现依赖于Java同步器框架AbstractQueuedSynchronizer(AQS)。AQS使用一个整型的volatile变量（state）来维护同步状态，这个变量时ReentrantLock内存语义实现的关键。
ReentrantLock的类图如下所示

ReentrantLock分为公平锁和非公平锁，我们首先分析公平锁。
使用公平锁时，加锁方法lock()调用轨迹如下
1）ReentrantLock：lock()；
2）FairLock：lock()；
3）AbstractQueuedSynchronizer：acquire(int arg)；
4）ReentrantLock：tryAcquire(int acquires)。
第四步真正开始加锁，下面是该方法的源码

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState(); // 获取锁的开始，首先读取volatile变量state
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    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;
        }

使用公平锁时，解锁方法unlock()调用轨迹如下
1）ReentrantLock：unlock()；
2）AbstractQueuedSynchronizer：release(int arg)；
3）Sync：tryRelease(int releases)。
第三步真正开始释放锁，下面是该方法的源码

        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变量，根据volatile的happens-before规则，释放锁的线程在写volatile变量之前可见的共享变量，在获取锁的线程读取同一个volatile变量后立即变得对获取锁的线程可见。

  现在我们来分析非公平锁的内存语义的实现。非公平锁的释放和公平锁完全一样，所以这里仅仅分析非公平锁的获取。使用非公平锁时，加锁方法lock()调用轨迹如下
1）ReentrantLock：lock()；
2）NonFairSync：lock()；
3）AbstractQueuedSynchronizer：compareAndSetState(int expect,int update)。
第三步真正开始加锁，下面是该方法源码

	/**
	 * 该方法以原子操作的方式更新state变量，JDK中对该方法的说明：如果当前状态值等于预期值，
	 * 则以原子方式将同步状态设置为给定的更新值。此操作具有volatile读和写的内存语义。
	 */
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

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

4.conurrent包的实现

  由于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变量。
  仔细分析concurrent包下的源码我们会发现一个通用化的实现模式
首先声明共享变量为volatile，然后使用CAS的原子条件更新来实现线程之间的同步，同时配以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信。
  AQS，非阻塞数据结构和原子变量类，这些concurrent包中的基础类都是使用这种模式来实现的，而concurrent包中的高层类又是依赖于这些基础类来实现的。

---