发布于2021-06-14 09:43 阅读(654) 评论(0) 点赞(23) 收藏(5)
锁的作用是让临界区互斥执行。本文阐述所得另一个重要知识点——锁的内存语义。
锁是Java并发编程中最重要的同步机制。锁除了让临界区互斥执行外,还可以让释放锁的线程向获取同一个锁的线程发送消息。
锁释放-获取的示例代码:
package com.lizba.p1;
/**
* <p>
* 锁示例代码
* </p>
*
* @Author: Liziba
* @Date: 2021/6/10 21:43
*/
public class MonitorExample {
int a = 0;
public synchronized void writer() { // 1;
a++; // 2;
} // 3;
public synchronized void reader() { // 4;
int i = a; // 5;
System.out.println(i);
} // 6;
}
假设线程A执行writer()方法,随后线程B执行reader()方法。根据happens-before规范,这个过程包含的happens-before关系可以分为3类。
上述happens-before关系的图形化表现形式如图:
总结:
线程A在释放锁之前所有可见的共享变量,在线程B获取同一个锁之后,将立即变得对B线程可见。
当线程释放锁时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。以上述MonitorExample程序为例,A线程释放锁后,共享数据的状态示意图如下所示:
当线程获取锁时,JMM会把该线程对应的本地内存置为无效。从而使得被监视器锁保护的临界区代码必须从主内存中读取共享变量。
对比锁释放-获取锁的内存语义与volatile写-读的内存语义可以看出:锁释放与volatile写有相同的内存语义;锁获取与volatile读有相同的内存语义。
总结:
分析ReentrantLock的源代码,来分析锁内存语义的具体实现机制。
示例代码:
package com.lizba.p1;
import java.util.concurrent.locks.ReentrantLock;
/**
* <p>
* ReentrantLock示例代码
* </p>
*
* @Author: Liziba
* @Date: 2021/6/10 22:17
*/
public 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;
System.out.println(i);
} finally {
lock.unlock(); // 释放锁
}
}
}
在ReentrantLock中,调用lock()方法获取锁;调用unlock()方法释放锁。
ReentrantLock的实现依赖于Java同步器框架AbstractQueuedSynchronized(AQS)。AQS使用一个整型的volatile变量(state)来维护同步状态,这个volatile变量是ReentrantLock内存语义实现的关键。
ReentrantLock分为公平锁和非公平锁,首先分析公平锁。
使用公平锁时,加锁方法lock()的调用轨迹如下。
第4步开始真的加锁,下面是该方法的源代码:
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 获取锁开始,首先读取volatile变量state
int c = getState();
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;
}
从上面的代码中可以看出,加锁方法首先读取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);
}
// 释放锁的最后,写volatile变量state
setState(c);
return free;
}
从上面的代码中可以看出,释放锁的最后写volatile变量state。
总结公平锁:
根据volatile的happens-before规则,释放锁的线程在写volatile变量之前可见的共享变量,在获取锁的线程读取到同一个volatile变量后将立即变得对获取锁的线程可见。
现在分析非公平锁:
注意,非公平锁的释放和公平锁的释放完全一致,都是上面的源代码。所以下面只分析非公平锁的获取过程。
使用非公平锁,加锁方法lock()的调用轨迹如下:
第3步开始真的加锁,下面是该方法的源代码:
// 方法1
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 此方法中开始加锁
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
// 方法2
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
// 该方法是native方法,在JVM中实现
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
该方法以原子操作的方式更新state变量,也就是compareAndSet() (CAS)操作。JDK文档对该方法说明如下:如果当前状态值等于预期值,则以原子方式同步状态设置为给定更新的值。此操作具有volatile读和写的内存语义。
接下来分别从编译器和处理器的角度来分析,CAS如何同时具有volatile读和volatile写的内存语义。
编译器的角度:
前文已经讲过,编译器不会对volatile读与volatile读后面的任意内存操作重排序;编译器不会对volatile写和volatile写后前面的任意内存操作重排序。组合这两个条件,意味着同时实现volatile读和volatile写的内存语义,编译器不能对CAS与CAS前面和后面任意内存操作重排序。
处理器的角度:
(本人不太懂C++)这一块总结需要看JVM源码,可能会总结错误,如需要深入理解这一块请查看《Java并发编程艺术》53页。
sun.misc.Unsafe中的compareAndSwapInt源码如下:(不懂Unsafe请看往期文章)
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
这是一个本地方法。这个本地方法会在openJDK中调用C++代码,假设当前是X86处理器,程序会根据当前处理器的类型来决定是非cmpxchg指令添加lock前缀。如果:
intel手册对lock前缀的说明
上面的2、3两点所具有的内存屏障的效果,足以同时实现volatile读和volatile写的内存语义。所以JDK文档说CAS 具有volatile读和volatile写的内存语义对于处理器也是符合的。
公平锁和非公平锁的总结
释放锁-获取锁的内存语义的实现方式总结
由于Java的CAS同时具有volatile读和volatile写的内存语义,因此Java线程之间的通信方式有以下4种方式
Java的CAS会使用现代处理器上提供的高效机器级别的原子指令,这些原子指令以原子方式对内存执行读-改-写操作,这是在多处理器实现同步的关键。同时volatile变量的读/写和CAS可以实现线程之间的通信。这些特性就是Java整个concurrent包的基石。
concurrent包的通用化实现模式
AQS(java.util.concurrent.locks.AbstractQueuedSynchronizer)、非阻塞数据结构和原子变量类(java.util.concurrent.atomic包中的类),这些concurrent包中基础类都是使用这个模式来实现的,而concurrent包中的高层类又是依赖于这些基础类。
图示concurrent包的实现示意图
文章总结至《Java并发编程艺术》,下篇总结“final域的内存语义”,敬请关注。
作者:我爱编程
链接:http://www.javaheidong.com/blog/article/222623/79b1e13686bb16dcfb81/
来源:java黑洞网
任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任
昵称:
评论内容:(最多支持255个字符)
---无人问津也好,技不如人也罢,你都要试着安静下来,去做自己该做的事,而不是让内心的烦躁、焦虑,坏掉你本来就不多的热情和定力
Copyright © 2018-2021 java黑洞网 All Rights Reserved 版权所有,并保留所有权利。京ICP备18063182号-2
投诉与举报,广告合作请联系vgs_info@163.com或QQ3083709327
免责声明:网站文章均由用户上传,仅供读者学习交流使用,禁止用做商业用途。若文章涉及色情,反动,侵权等违法信息,请向我们举报,一经核实我们会立即删除!