锁的释放-获取建立的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 关系可以分为两类:
上述happens before 关系的图形化表现形式如下: 在上图中,每一个箭头链接的两个节点,代表了一个happens before 关系。黑色箭头表示程序顺序规则;橙色箭头表示监视器锁规则;蓝色箭头表示组合这些规则后提供的happens before保证。 上图表示在线程A释放了锁之后,随后线程B获取同一个锁。在上图中,2 happens before 5。因此,线程A在释放锁之前所有可见的共享变量,在线程B获取同一个锁之后,将立刻变得对B线程可见。 锁释放和获取的内存语义当线程释放锁时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。以上面的MonitorExample程序为例,A线程释放锁后,共享数据的状态示意图如下: 当线程获取锁时,JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须要从主内存中去读取共享变量。下面是锁获取的状态示意图: 对比锁释放-获取的内存语义与volatile写-读的内存语义,可以看出:锁释放与volatile写有相同的内存语义;锁获取与volatile读有相同的内存语义。 下面对锁释放和锁获取的内存语义做个总结:
锁内存语义的实现本文将借助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()方法释放锁。 ReentrantLock的实现依赖于java同步器框架AbstractQueuedSynchronizer(本文简称之为AQS)。AQS使用一个整型的volatile变量(命名为state)来维护同步状态,马上我们会看到,这个volatile变量是ReentrantLock内存语义实现的关键。 下面是ReentrantLock的类图(仅画出与本文相关的部分): ReentrantLock分为公平锁和非公平锁,我们首先分析公平锁。 使用公平锁时,加锁方法lock()的方法调用轨迹如下:
在第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。 在使用公平锁时,解锁方法unlock()的方法调用轨迹如下:
在第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()的方法调用轨迹如下:
在第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前缀的说明如下:
上面的第2点和第3点所具有的内存屏障效果,足以同时实现volatile读和volatile写的内存语义。 经过上面的这些分析,现在我们终于能明白为什么JDK文档说CAS同时具有volatile读和volatile写的内存语义了。 现在对公平锁和非公平锁的内存语义做个总结:
从本文对ReentrantLock的分析可以看出,锁释放-获取的内存语义的实现至少有下面两种方式:
concurrent包的实现由于java的CAS同时具有 volatile 读和volatile写的内存语义,因此Java线程之间的通信现在有了下面四种方式:
Java的CAS会使用现代处理器上提供的高效机器级别原子指令,这些原子指令以原子方式对内存执行读-改-写操作,这是在多处理器中实现同步的关键(从本质上来说,能够支持原子性读-改-写指令的计算机器,是顺序计算图灵机的异步等价机器,因此任何现代的多处理器都会去支持某种能对内存执行原子性读-改-写操作的原子指令)。同时,volatile变量的读/写和CAS可以实现线程之间的通信。把这些特性整合在一起,就形成了整个concurrent包得以实现的基石。如果我们仔细分析concurrent包的源代码实现,会发现一个通用化的实现模式:
AQS,非阻塞数据结构和原子变量类(java.util.concurrent.atomic包中的类),这些concurrent包中的基础类都是使用这种模式来实现的,而concurrent包中的高层类又是依赖于这些基础类来实现的。从整体来看,concurrent包的实现示意图如下: 参考文献关于作者程晓明,Java软件工程师,国家认证的系统分析师、信息项目管理师。专注于并发编程,就职于富士通南大。个人邮箱:http://www./cn/articles/mailto:asst2003@163.com。 社区评论 Watch Thread
cas和volatile关系 三月 19, 2013 09:59by 感谢作者,帮我把之前零散的知识串起来。
我理解:cas包括两部分 1.lock:保证具体‘volatile内存语义’ 2.cmpxchg:保证原子操作 -> lock是volatile在intel平台的具体实现,对吗 ? -> 若上述不成了,是说cas自身就具体1、2特性,若去掉‘private volatile int state;’volatile,是否仍满足 ? 引用“从整体来看,concurrent包的实现示意图如下”,是把‘volatile’和‘cas’是放在同一层。 谢谢 Re: cas和volatile关系 三月 20, 2013 12:12by 引用“从整体来看,concurrent包的实现示意图如下”,是把‘volatile’和‘cas’是放在同一层。
--把‘volatile的读/写’和‘CAS’是放在同一层,是想回应第一章提到的:“并发编程中,我们需要处理两个关键问题:线程之间如何通信及线程之间如何同步” java的concurrent包通过volatile的读/写,及CAS所具有的volatile读和volatile写的内存语义,来实现线程之间的通信。 java的concurrent包使用CAS来实现线程之间的同步。 锁与共享内存的疑问 三月 20, 2013 03:08by 1.“当线程获取锁时,JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须要从主内存中去读取共享变量。”
2.“当线程释放锁时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。” 从文中提到的这2点,我的理解是这样的: 在临界区内:共享变量只能从主内存中读取;共享变量的写操作只能在本地内存中进行,因为在离开临界区的时候本地内存中的共享变量需要被刷新到主内存中,如果写操作直接是写入主内存,那么最终会因为本地内存和主内存中的共享变量不一致而导致主内存中的共享变量没有得到应有的更新。 另外我有一个疑问:将本地内存的共享变量刷新到主内存中的时候,是刷新本地内存中的所有共享变量还是只刷新那些发生过写操作的共享变量? Re: 锁与共享内存的疑问 三月 23, 2013 11:03by --离开临界区的时候本地内存中的共享变量需要被刷新到主内存中.
这是锁内存语义的需要。 如果当前线程A在离开临界区时(释放锁时),还不把本地内存钟的共享变量刷新到主内存; 那么接下来获取这个锁的线程B,将无法读到线程A对共享变量所做的修改。 因此,“离开临界区的时候,本地内存中的共享变量需要被刷新到主内存中”,是锁通信机制(锁内存语义)的需要。 --是刷新本地内存中的所有共享变量还是只刷新那些发生过写操作的共享变量? 个人觉得,可以理解为只刷新那些发生过写操作的共享变量。 “本地内存,主内存,从主内存中读取变量,刷新共享变量到主内存”,这些都是为了易于读者理解而虚构出来的。事实上,与JSR-133内存模型相关的两大规范都没有提到这些概念: 1:《JSR-133: JavaTM Memory Model and Thread Specification》 2:《The Java? Language Specification Third Edition》的“17.4 Memory Model” 与JSR-133内存模型相关的著作中,映像中好像只有Brian Goetz在下面这篇文章中提到了这些概念: http://www.ibm.com/developerworks/java/library/j-jtp03304/index.html 个人觉得这些概念形象,生动,易于读者理解。所以就把它们借鉴到本文中来了:) 但我个人感觉,使用这些概念也会有弊端。所以本文中,我只是简单提到它们。 对于JSR-133内存模,重点应该关注happens before ,以及编译器重排序规则和处理器内存屏障插入策略。 |
|
来自: wlj2004 > 《java内存模型》