内置锁使用
通常我们说的 java 内置锁默认都是指的 JVM 给我们提供的 synchronized 关键字实现的锁。 下面是一个简单的例子：
public class SynchronizedVariableTest1 {
public static void main(String[] args) throws InterruptedException {
SynchronizedVariableTest1 test = new SynchronizedVariableTest1();
synchronized (test) {
System.out.println(1);
}
}
}
复制代码对象加锁
我们可以通过 javap命令查看字节码文件，或者通过 idea 的jclasslib Bytecode Viewer插件进行查看字节码指令信息，如下图所示：
我们看到 synchronized 底层是使用 monitor 机制来实现锁的获取、释放。会在代码快前后增加 monitorenter 、monitorexit 指令。
**锁定对象不能是 null ， 如果是 null 程序运行的时候会提示 ****NullPointerException**空指针异常。
Object lock = null;
synchronized(lock) {
System.out.println(100);
}
// 结果:
// Exception in thread "main" java.lang.NullPointerException
// at cn.xyz.juc.synchronized1.status.CleanLockTest.main(CleanLockTest.java:16)
复制代码
方法加锁
同样，如果是在方法上增加 synchronized关键字（由于jclasslib Bytecode Viewer查看方法信息不是很方便，下面我就通过 javap -verbose指令来进行演示），会在方法的 flags 上增加 ACC_SYNCHRONIZED关键字，原方法代码如下：
public synchronized void test() {
}
复制代码编译后的字节码， 执行指令 javap -verbose xxxx.class
public synchronized void test();
descriptor: ()V
flags: (0x0021) ACC_PUBLIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=1, args_size=1
0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
3: iconst_1
4: invokevirtual #6 // Method java/io/PrintStream.println:(I)V
line 14: 21
LocalVariableTable:
Start Length Slot Name Signature
0 22 0 this Lcn/xyz/juc/synchronized1/SynchronizedVariableTest2;
复制代码对于 .class字节码文件的解析和分析可以参考这篇掘金文章: JVM 字节码指令解析 。
内置锁状态存储
内置锁的状态是存储到 Java 对象的对象头中，对象头的存储结构，以及对象内存分配可以参考我的这篇文章: 基于 Hostpot 虚拟机的 Java 对象揭秘 。本文不再赘述。
Mark Word （64bit）
为了方便下文阅读，我吧 mark word 再贴一次到本文中
Java 管程
Java 虚拟机可以支持方法级的同步和方法内部一段指令序列的同步，这两种同步结构都是采用管程（Monitor， 更常见的是直接称为 “锁”）来实现的。
Java 采用的是管程技术，synchronized 关键字及 wait()、notify()、notifyAll() 这三个方法都是管程的组成部分。而管程和信号量是等价的，所谓等价指的是用管程能够实现信号量，也能用信号量实现管程。但是管程利用OOP的封装特性解决了信号量在工程实践上的复杂性问题，因此java采用管理机制。
MESA 模型
管程模型，分别是：Hasen 模型、Hoare 模型和 MESA 模型。其中，现在广泛应用的是 MESA 模型，并且 Java 管程的实现参考的也是 MESA 模型。
在并发编程领域，有两大核心问题：一个是互斥，即同一时刻只允许一个线程访问共享资源；另一个是同步，即线程之间如何通信、协作。这两大问题，管程都是能够解决的。
ObjectMonitor
ObjectMonitor 在 jvm 中的定义信息如下：
// initialize the monitor, exception the semaphore, all other fields
// are simple integers or pointers
ObjectMonitor() {
_header = NULL; // 对象头
_count = 0;
_waiters = 0,
_recursions = 0; // 锁重入次数
_object = NULL; // 存储锁对象
_owner = NULL; // 标识拥有该 monitor 的线程（当前获取锁的线程）
_WaitSet = NULL; // 等待线程（调用 waite） 组成的双向循环链表 _WaitSet 是第一个节点
_WaitSetLock = 0 ;
_Responsible = NULL ;
_succ = NULL ;
_cxq = NULL ; // 多线程竞争锁会先存储到这个单向链表中（FIFO）结构
FreeNext = NULL ; // 存放在进入或者重新进入时被阻塞（Blocked）的线程（也就是竞争失败的线程）
_EntryList = NULL ;
_SpinFreq = 0 ;
_SpinClock = 0 ;
OwnerIsThread = 0 ;
_previous_owner_tid = 0;
}
复制代码内置锁状态
内置锁分为 4 个状态，分别是：无锁，偏向锁，轻量级锁，重量级锁。在锁竞争的过程中会进行一个正向的锁升级过程。
锁升级过程
说明，锁升级状态是不可逆转的。
无锁状态
实验代码：
public class NoSynchronizedTest {
public static void main(String[] args) {
NoSynchronizedTest test = new NoSynchronizedTest();
System.out.println("无锁状态 +++++++++");
System.out.println(ClassLayout.parseInstance(test).toPrintable());
}
}
复制代码输出结果
无锁状态 +++++++++
cn.xyz.juc.synchronized1.NoSynchronizedTest object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 01 00 00 00 (00000001 00000000 00000000 00000000) (1)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 05 c0 00 f8 (00000101 11000000 00000000 11111000) (-134168571)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
复制代码字段解释：
- OFFSET : 地址偏移量，单位字节；
- SIZE: 占用内存大小，单位字节；
- TYPE DESCRIPTION: 类型描述，其中 object header 为对象头；
- VALUE： 对应内存中当前存储的值，二进制 32 ；
指针压缩
打印的结果我们可以看到，对象总大小位 16 字节，前 12 字节为对象头（我本地 jdk 1.8 默认开启指针压缩），后面 4 字节为对齐填充。
可以通过一下参数进行关闭：
-XX:-UseCompressedOops
复制代码我再执行一次，对象总大小 16 bytes, 前 8 bytes 是 mark word ， 后 8 bytes 表示 kclass point
匿名偏向
当 JVM 启用了偏向锁模式（JDK 6默认开启），创建新的 Mark Word 的 Thread Id 为 0， 说明此时处于可偏向但是并未偏向任何线程，也叫做匿名偏向状态（anonymously biased）
偏向锁状态
偏向锁延迟偏向
**偏向锁模式存在偏向锁延迟机制： **Hostpost 虚拟机再启动后有一个几秒（默认 4 秒）的延迟才对妈给新对象进行开启偏向锁模式。 JVM 启动时会进行一系列的对象创建过程。在这个过程中大量 synchronized 关键字对对象加锁，这些锁多数都不是偏向锁。为了减少初始化时间， jvm 默认延迟加载偏向锁。
JVM 参数：
//关闭延迟开启偏向锁
‐XX:BiasedLockingStartupDelay=0
//禁止偏向锁
‐XX:‐UseBiasedLocking
//启用偏向锁
‐XX:+UseBiasedLocking
复制代码测试代码（注意，这里需要注意的是需要创建两个对象，因为对象头信息的初始化是在 new关键字执行的时候初始化，笔者之前就遇到了这样的问题，导致实验失败）：
public class BiasedLockDelayTest {
public static void main(String[] args) throws InterruptedException {
Object obj1 = new Object();
System.out.println(ClassLayout.parseInstance(obj1).toPrintable());
System.out.println();
Thread.sleep(5000);
Object obj2 = new Object();
System.out.println(ClassLayout.parseInstance(obj2).toPrintable());
}
}
复制代码结果打印如下，延迟 5 秒后新创建的都默认开启匿名偏向， threadid = 0 。
偏向锁偏向状态跟踪
下面代码主要演示了对象从无锁，到偏向锁的过程。代码如下：
log.debug(ClassLayout.parseInstance(new Object()).toPrintable());
Thread.sleep(4000);
Object obj1 = new Object();
log.debug(ClassLayout.parseInstance(obj1).toPrintable());
new Thread(new Runnable() {
@Override
public void run() {
log.debug("start ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
synchronized (obj1) {
log.debug("lock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
log.debug("unlock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
}, "thread0").start();
Thread.sleep(5000);
log.debug(ClassLayout.parseInstance(obj1).toPrintable());
复制代码打印结果如下：
偏向锁状态调用 hashcode 方法
调用锁对兑现的 obj.hashCode() 或者 System.identityHashCode(obj) 方法时候会导致该对象的偏向锁被撤销。因为一个对象，其 hashcode 只会被生成一次并且保存，偏向锁是没有地方存储 hashcode 的
- 轻量级锁会在锁记录中记录 hashCode
- 重量级锁会在 Monitor 中记录 hashCode
当对象处于可偏向（也就是线程 ID 为0）和已偏向的状态下，调用 hashCode 计算会将使对象也无法偏向：
- 当对象可偏向时， MarkWord 将编程未锁定状态，并且只能升级成轻量级锁
- 当对象正处于偏向锁时， 调用 hashCode 使偏向锁强制升级为重量级锁
实验代码：
偏向锁内调用，共享对象 obj1 的 hashCode 方法，锁被升级为重量级锁。
偏向锁状态调用 wait/notify
偏向锁状态执行 obj.notify 会升级为轻量级锁。
调用 obj.wait(timeout) 会升级为重量级锁。
轻量级锁状态
如果偏向锁失败， 虚拟机并不会升级为重量级锁，它还会尝试使用一种称为轻量锁的优化手段，此时 Mark Word 的结构也会变成轻量级锁的结构，轻量级锁所适应的场景就是线程交替执行同步块的场合，如果存在同一个时间多个线程访问同一把锁的场合，就会导致轻量级锁膨胀为重量级锁。
偏向锁升级为轻量级锁
@Slf4j
public class LightweightLockTest {
public static void main(String[] args) throws InterruptedException {
log.debug(ClassLayout.parseInstance(new Object()).toPrintable());
Thread.sleep(5000);
Object obj1 = new Object();
log.debug(ClassLayout.parseInstance(obj1).toPrintable());
new Thread(new Runnable() {
@SneakyThrows
@Override
public void run() {
log.debug("start ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
synchronized (obj1) {
log.debug("lock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
log.debug("unlock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
}, "thread0").start();
Thread.sleep(1000);
new Thread(new Runnable() {
@SneakyThrows
@Override
public void run() {
log.debug("start ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
synchronized (obj1) {
log.debug("lock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
log.debug("unlock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
}, "thread1").start();
Thread.sleep(5000);
log.debug(ClassLayout.parseInstance(obj1).toPrintable());
}
}
复制代码打印日志：
由于日志过长无法标记，我就简单的画一个流程图吧
轻量级锁升级为重量级锁
需要制造竞争激烈的场景，我们可以通过线程池的方式来模拟，代码如下：
@Slf4j
public class LightweightLockTest {
public static void main(String[] args) throws InterruptedException {
log.debug(ClassLayout.parseInstance(new Object()).toPrintable());
Thread.sleep(5000);
Object obj1 = new Object();
log.debug(ClassLayout.parseInstance(obj1).toPrintable());
ExecutorService executeService = Executors.newFixedThreadPool(2);
executeService.submit(new Thread(new Runnable() {
@SneakyThrows
@Override
public void run() {
log.debug("start ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
synchronized (obj1) {
log.debug("lock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
log.debug("unlock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
}, "thread0"));
//Thread.sleep(1000);
executeService.submit(new Thread(new Runnable() {
@SneakyThrows
@Override
public void run() {
log.debug("start ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
synchronized (obj1) {
log.debug("lock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
log.debug("unlock ... \r\n" + ClassLayout.parseInstance(obj1).toPrintable());
}
}, "thread1"));
Thread.sleep(5000);
log.debug(ClassLayout.parseInstance(obj1).toPrintable());
}
}
复制代码我们再来看看结果： 第一个线程获取锁过后，锁由偏向锁升级为轻量级锁
第二个线程已经采用的是重量级锁。 �说明：为什么有时候没有升级成重量级锁？这个可能是当是 CPU 资源比较空闲，计算逻辑处理能力比较强，不需要进行锁升级，大家可以尝试多增加几个线程参与锁的争抢或者该程序多运行几次。
锁的状态转化
偏向锁、轻量级锁的状态转化及对象 Mark Word 的关系转换入下图所示：
原文链接：https://juejin.cn/post/7055665818176061453
京公网安备 11010502036488号