* @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类。
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关系的图形化表现形式如图：
**总结：**
线程A在释放锁之前所有可见的共享变量，在线程B获取同一个锁之后，将立即变得对B线程可见。
#### 2、锁释放和获取的内存语义
当线程释放锁时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。以上述MonitorExample程序为例，A线程释放锁后，共享数据的状态示意图如下所示：
**共享数据的状态示意图**
当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器锁保护的临界区代码必须从主内存中读取共享变量。
**锁获取的状态示意图**
对比锁释放-获取锁的内存语义与volatile写-读的内存语义可以看出：锁释放与volatile写有相同的内存语义；锁获取与volatile读有相同的内存语义。
**总结：**
* 线程A释放锁，实质上是线程A向接下来要获取这个锁的某个线程发出了（线程A对共享变量所做修改的）消息。
* 线程B获取锁，实质上是线程B接受了之前某个线程发出的（在释放这个锁对共享变量锁做的修改的）消息。
* 线程A是否锁，随后线程B获取这个锁，这个**过程实质上是线程A通过主内存向线程B发送消息**。
#### 3、锁内存的语义实现
分析ReentrantLock的源代码，来分析锁内存语义的具体实现机制。
示例代码：
package com.lizba.p1;
import java.util.concurrent.locks.ReentrantLock;
/** *
* ReentrantLock示例代码 *
* * @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内存语义实现的关键。
**ReetrantLock的类图**
**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(); // 获取锁开始，首先读取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()调用轨迹如下：
1. ReentrantLock: unlock()
2. AbstractQueuedSynchronizer: release(int arg)
3. Sync: tryRelease(int release)
第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()的调用轨迹如下：
1. ReentrantLock: lock()
2. NonfairSync: lock()
3. AbstractQueuedSynchronizer: compareAndSetState(int expect, int update)
第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);
结尾
学习html5、css、javascript这些基础知识，学习的渠道很多，就不多说了，例如，一些其他的优秀博客。但是本人觉得看书也很必要，可以节省很多时间，常见的javascript的书，例如：javascript的高级程序设计，是每位前端工程师必不可少的一本书，边看边用，了解js的一些基本知识，基本上很全面了，如果有时间可以读一些，js性能相关的书籍，以及设计者模式，在实践中都会用的到。
高级程序设计，是每位前端工程师必不可少的一本书，边看边用，了解js的一些基本知识，基本上很全面了，如果有时间可以读一些，js性能相关的书籍，以及设计者模式，在实践中都会用的到。
