BT

如何利用碎片时间提升技术认知与能力? 点击获取答案

深入理解Java内存模型(五)——锁

| 作者 程晓明 关注 81 他的粉丝 发布于 2013年3月6日. 估计阅读时间: 23 分钟 | QCon上海2018 关注大数据平台技术选型、搭建、系统迁移和优化的经验。

锁的释放-获取建立的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 关系可以分为两类:

  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获取同一个锁。在上图中,2 happens before 5。因此,线程A在释放锁之前所有可见的共享变量,在线程B获取同一个锁之后,将立刻变得对B线程可见。

锁释放和获取的内存语义

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

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

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

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

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

锁内存语义的实现

本文将借助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()的方法调用轨迹如下:

  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。

在使用公平锁时,解锁方法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变量之前可见的共享变量,在获取锁的线程读取同一个volatile变量后将立即变的对获取锁的线程可见。

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

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

使用公平锁时,加锁方法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写前面的任意内存操作重排序。组合这两个条件,意味着为了同时实现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前缀的说明如下:

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

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

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

现在对公平锁和非公平锁的内存语义做个总结:

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

从本文对ReentrantLock的分析可以看出,锁释放-获取的内存语义的实现至少有下面两种方式:

  1. 利用volatile变量的写-读所具有的内存语义。
  2. 利用CAS所附带的volatile读和volatile写的内存语义。

concurrent包的实现

由于java的CAS同时具有 volatile 读和volatile写的内存语义,因此Java线程之间的通信现在有了下面四种方式:

  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包的源代码实现,会发现一个通用化的实现模式:

  1. 首先,声明共享变量为volatile;
  2. 然后,使用CAS的原子条件更新来实现线程之间的同步;
  3. 同时,配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信。

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

参考文献

  1.         Concurrent Programming in Java: Design Principles and Pattern

  2.         JSR 133 (Java Memory Model) FAQ

  3.         JSR-133: Java Memory Model and Thread Specification

  4.         Java Concurrency in Practice

  5.         Java™ Platform, Standard Edition 6 API Specification

  6.         The JSR-133 Cookbook for Compiler Writers

  7.         Intel® 64 and IA-32 ArchitecturesvSoftware Developer’s Manual Volume 3A: System Programming Guide, Part 1

  8.         The Art of Multiprocessor Programming

关于作者

程晓明,Java软件工程师,国家认证的系统分析师、信息项目管理师。专注于并发编程,就职于富士通南大。个人邮箱:asst2003@163.com

评价本文

专业度
风格

您好,朋友!

您需要 注册一个InfoQ账号 或者 才能进行评论。在您完成注册后还需要进行一些设置。

获得来自InfoQ的更多体验。

告诉我们您的想法

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

cas和volatile关系 by fatmind fatmind

感谢作者,帮我把之前零散的知识串起来。

我理解:cas包括两部分
1.lock:保证具体‘volatile内存语义’
2.cmpxchg:保证原子操作

-> lock是volatile在intel平台的具体实现,对吗 ?
-> 若上述不成了,是说cas自身就具体1、2特性,若去掉‘private volatile int state;’volatile,是否仍满足 ?

引用“从整体来看,concurrent包的实现示意图如下”,是把‘volatile’和‘cas’是放在同一层。

谢谢

Re: cas和volatile关系 by 程 晓明

引用“从整体来看,concurrent包的实现示意图如下”,是把‘volatile’和‘cas’是放在同一层。
--把‘volatile的读/写’和‘CAS’是放在同一层,是想回应第一章提到的:“并发编程中,我们需要处理两个关键问题:线程之间如何通信及线程之间如何同步”
java的concurrent包通过volatile的读/写,及CAS所具有的volatile读和volatile写的内存语义,来实现线程之间的通信。
java的concurrent包使用CAS来实现线程之间的同步。

锁与共享内存的疑问 by p hk

1.“当线程获取锁时,JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须要从主内存中去读取共享变量。”
2.“当线程释放锁时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。”

从文中提到的这2点,我的理解是这样的:
在临界区内:共享变量只能从主内存中读取;共享变量的写操作只能在本地内存中进行,因为在离开临界区的时候本地内存中的共享变量需要被刷新到主内存中,如果写操作直接是写入主内存,那么最终会因为本地内存和主内存中的共享变量不一致而导致主内存中的共享变量没有得到应有的更新。

另外我有一个疑问:将本地内存的共享变量刷新到主内存中的时候,是刷新本地内存中的所有共享变量还是只刷新那些发生过写操作的共享变量?

Re: 锁与共享内存的疑问 by 程 晓明

--离开临界区的时候本地内存中的共享变量需要被刷新到主内存中.
这是锁内存语义的需要。
如果当前线程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在下面这篇文章中提到了这些概念:
www.ibm.com/developerworks/java/library/j-jtp03...
个人觉得这些概念形象,生动,易于读者理解。所以就把它们借鉴到本文中来了:)
但我个人感觉,使用这些概念也会有弊端。所以本文中,我只是简单提到它们。

对于JSR-133内存模,重点应该关注happens before ,以及编译器重排序规则和处理器内存屏障插入策略。

对锁之前如何保证数据同步的问题? by 秦 军

非常感谢作者的这一系列文章,收货蛮大。有一个疑问,在线程中对一个对象同步之前,如何保证线程内的本地内存写到主内存中呢?因为看了文章,同步锁进入前,本地内存会无效,那么我对一个变量操作了,会写到主线程吗?eg :
Obj obj ;
obj.x = 10;

synchronized (obj) {
// ...
}

reader和writer方法应该是对象锁 by fish fish

请问作者,线程A应该是获取到线程A的对象锁,B是获取到B的对象锁吧?不会存在获取同一个对象的情况吧

Re: reader和writer方法应该是对象锁 by 程 晓明

如果一个对象在线程A和线程B之间共享时,当调用这个共享对象的同步方法时,线程A和线程B获取的就是同一个锁。
以本文的MonitorExample为例:
MonitorExample shareObject = new MonitorExample();
new ThreadA(shareObject).start();
new ThreadB(shareObject).start();
当在ThreadA和ThreadB的run()中,分别执行shareObject.writer()和shareObject.reader()时,它们获取的就是同一个对象的锁。

Re: 对锁之前如何保证数据同步的问题? by 程 晓明

不好意思,回复晚了。
这个问题和上面"p hk”的问题有点类似。
正如上面的回复所言,本地内存和主内存都是为了让读者更形象生动的理解内存模型而虚构出来的。
你可以把这个场景理解为:当本地内存中的值比主内存中的值的版本更新时,这个值不会被置为无效。

对内存模型的理解,需要从happens-before着手。
比如,假设A线程的程序顺序如下:
Obj obj ;
obj.x = 10; //1
synchronized (obj) { //2
// ...
}

假设B线程的程序顺序如下:
synchronized (obj) { //3
// ...
}
int i = obj.x; //4

根据程序顺序规则,1 happens-before 2,3 happens-before 4.
如果线程A执行了操作2之后,B线程执行操作3,那么:1 happens-before 4
也就是说:线程A在1的写入操作,线程B在4一定能看到。

Re: cas和volatile关系 by Jesse Q

LZ是不是说 CAS 是使用volatile 的特性刷新新的数据到内存,那么使用CAS的时候是不是 比较或替换的类型必须是一个volatile 类型?

Re: cas和volatile关系 by 黄 文海

不是的。这里使用volatile变量实际上是为了保证内存可见性,用它来实现刷新高速缓存和冲刷Store Buffer的。说白了是利用了volatile的“副作用”来保障可见性,因此这种技术被称为驮背运输(Piggyback)。

Re: 对锁之前如何保证数据同步的问题? by 黄 文海

属性x的值在同步块执行结束后会被写入高速缓存。但是同步在obj上的另外一个线程不一定就能读取到相应的值,因为要看这个线程是在同步块内还是同步块外读取属性x的。
详细的分析如下:
假设线程1执行,
Obj obj ;
obj.x = 10;//语句①

synchronized (obj) {
// ...
}
首先,语句①不会被重排序到同步块之后。由于释放锁的动作具有冲刷(Flush)Store Buffer的效果,因此语句①的操作结果在同步块执行结束后会被“同步”到RAM(这么说只是为了便于理解,实际上只要保障属性x的值到了高速缓存就可以了,不一定要到RAM)。
其次,获得锁的动作具有刷新高速缓存的效果。因此,如果同步在obj上的另外一个线程是在临界区内访问属性x的,那么这个线程一定可以读取到线程1对属性x的更新(锁的排他性以及对可见性的保障保证了这点):
假设线程2执行,
synchronized (obj) {
read obj.x;//这里可以读取到前一个线程更新后的属性值
}
但是,如果这个线程是在同步块之外读取属性x的值,那么能否读取到上面的线程对属性x的更新是没有保障的。这使用因为Race Condition的存在:
假设线程2执行,
synchronized (obj) {

}
read obj.x;//语句②,这里无法保障该线程能够读取到前一个线程更新后的属性值

由于Race Condition的存在,线程2可能先于线程1执行(尽管它们同步在同一锁上),那么在线程1执行完同步块那一刻语句②刚好也开始执行。因此,语句②能否读取到线程1更新后的属性x值是没有保障的。

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

11 讨论

登陆InfoQ,与你最关心的话题互动。


找回密码....

Follow

关注你最喜爱的话题和作者

快速浏览网站内你所感兴趣话题的精选内容。

Like

内容自由定制

选择想要阅读的主题和喜爱的作者定制自己的新闻源。

Notifications

获取更新

设置通知机制以获取内容更新对您而言是否重要

BT