并发编程七：深入理解synchronized(上)

深入理解(上)

Java共享内存模型带来的线程安全问题

public class SyncDemo {private static int count = 0;public static void increment(){count++;}public static void decrement(){count--;}public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{for (int i = 0; i < 5000; i++) {increment();}},"t1");Thread t2 = new Thread(() -> {for (int i = 0; i < 5000; i++) {decrement();}},"t2");t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}

以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作。 我们可以查看 i++和 i–（i 为静态变量）的 JVM 字节码指令 （ 可以在idea中安装一个 插件）

i++的JVM 字节码指令

getstatic i // 获取静态变量i的值 
iconst_1 // 将int常量1压入操作数栈 
iadd // 自增 
putstatic i // 将修改后的值存入静态变量i

i–的JVM 字节码指令

getstatic i // 获取静态变量i的值 
iconst_1 // 将int常量1压入操作数栈 
isub // 自减
putstatic i // 将修改后的值存入静态变量i

如果是单线程以上 8 行代码是顺序执行没有问题。但多线程下这 8 行代码可能交错运行。

临界区（ ）

一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区，其共享资源为临界资源。

上面代码中()和()就是临界区， int count就是临界资源。

竞态条件（ Race ）

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件。

为了避免临界区的竞态条件发生，有多种手段可以达到目的：

的使用

同步块是 Java 提供的一种原子性内置锁，Java 中的每个对象都可以把它当作一个同步锁来使用，这些 Java内置的使用者看不到的锁被称为内置锁，也叫作监视器锁。

使用解决上述代码出现的问题。

private static String lock = "";
public static void increment(){synchronized (lock) {count++;}}
public static void decrement(){synchronized (lock) {count--;}}

底层原理

是JVM内置锁，基于机制实现，依赖底层操作系统的互斥原语 Mutex（互斥量），它是一个重量级锁，性能较低。当然，JVM内置锁在1.5之后版本做了重大的 优化，如锁粗化（Lock ）、锁消除（Lock ）、轻量级锁（ ）、偏向锁（ ）、自适应自旋（ ）等技术来减少锁操作的开销，内置锁的并发性能已经基本与Lock持平。

Java虚拟机通过一个同步结构支持方法和方法中的指令序列的同步：。 同步方法是通过方法中的中设置标志来实现；同步代码块是通过(加锁)和(解锁)来实现。两个指令的执行是JVM通过调用操作系统的互斥原语mutex来实现，被阻塞的线程会被挂起、等待重新调度，会导致“用户态和内核态”两个态 之间来回切换，对性能有较大影响。

public static void increment(){synchronized (lock) {count++;}}

上面代码的字节码指令

为什么会出现两个。当程序正常运行的时候第一个执行完后有一个goto到24行执行，就返回了。如果出现异常，就会执行第二个。我们在使用lock的时候，需要在里面执行lock.操作。但是并不需要。

public static synchronized void increment(){count++;}

加载方法上时

方法内部是不会有和指令的。但是在方法的(访问标志)上会有中设置标志。

加起来就是。

（管程/监视器）

，直译为“监视器”，而操作系统领域一般翻译为“管程”。管程是指管理共享变量以及对共享变量操作的过程，让它们支持并发。在Java 1.5之前，Java语言提供的唯一并发语言就是管程，Java 1.5之后提供的SDK并发包也是以管程为基础的。除了Java之外，C/C++、C#等 高级语言也都是支持管程的。关键字和wait()、()、()这三个方法是Java中实现管程技术的组成部分。

MESA模型

在管程的发展史上，先后出现过三种不同的管程模型，分别是Hasen模型、Hoare模型和MESA模型。现在正在广泛使用的是MESA模型。下面介绍MESA模型：

根据上图来看入口的等待队列比较好理解。条件变量等待队列主要是解决同步问题。

比如说一个线程进来了。其他线程被阻塞进入到等待队列。此时该线程需要另一个线程的结果，那么该线程执行wati()方法将自己处于等待状态，同时释放锁，那么另一个线程就可以执行了。等到另一个线程执行完成，执行()方法，唤醒等待的线程，这个等待的线程就处于条件变量等待队列中，优先获取锁。

对于MESA管程模型来说，wait()的使用有一个编程范式：

 while(条件不满足) {wait();
}

防止其他线程调用()，进行虚假唤醒。被唤醒的线程再次执行时可能条件又不满足了，所以循环检验条件。MESA模型的wait()方法还有一个超时参数，为了避免线程进入等待队列永久阻塞。

这个在wait()方法的注释中就有说到。

()和()分别何时使用

满足以下三个条件时，可以使用()，其余情况尽量使用()：

Java语言的内置管程

Java 参考了 MESA 模型，语言内置的管程（）对 MESA 模型进行了精简。MESA 模型中，条件变量可以有多个，Java 语言内置的管程里只有一个条件变量。模型如下图所示。

机制在Java中的实现

java.lang. 类定义了 wait()，()，() 方法，这些方法的具体实现，依赖 实现，这是JVM内部基于 C++ 实现的一套机制。

其主要数据结构如下（源码.hpp）：

ObjectMonitor() {_header       = NULL; //对象头  markOop_count        = 0;  _waiters      = 0,   _recursions   = 0;   // 锁的重入次数 _object       = NULL;  //存储锁对象_owner        = NULL;  // 标识拥有该monitor的线程（当前获取锁的线程） _WaitSet      = NULL;  // 等待线程（调用wait）组成的双向循环链表，_WaitSet是第一个节点_WaitSetLock  = 0 ;    _Responsible  = NULL ;_succ         = NULL ;_cxq          = NULL ; //多线程竞争锁会先存到这个单向链表中 （FILO栈结构）FreeNext      = NULL ;_EntryList    = NULL ; //存放在进入或重新进入时被阻塞(blocked)的线程 (也是存竞争锁失败的线程)_SpinFreq     = 0 ;_SpinClock    = 0 ;OwnerIsThread = 0 ;_previous_owner_tid = 0;

解释下重要的属性：owner当线程1占有锁的时候，就指向线程1。cxq当线程竞争锁失败后进入到这个链表。当持有锁的线程执行wait方法等待后，根据不同的策略可能进入到cxq，也可能进入到。

在获取锁时，是将当前线程插入到cxq的头部，而释放锁时，默认策略（QMode=0）是：如果为空，则将 cxq中的元素按原有顺序插入到，并唤醒第一个线程，也就是当为空时，是后来的线程先获取锁。不为空，直接从中唤醒线程。

锁在对象中标识

对象的内存布局

加锁加在对象上，锁对象是如何记录锁状态的？

虚拟机中，对象在内存中存储的布局可以分为三块区域：对象头（）、实例数据 （ Data）和对齐填充（）。

对于这部分内容在jvm专门专题中再说。

回到之前的问题： 加锁加在对象上，对象是如何记录锁状态的？锁状态被记录在每个对象的对象头的Mark Word中

对象头是如何记录锁状态的

对象头分为三个部分：Mark Word、Klass 、数组长度（只有数组对象有）

Mark Word：用于存储对象自身的运行时数据，如哈希码（）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分数据的长度在32位和64位的虚拟机中分别为 32bit和64bit，官方称它为“Mark Word”。

其他两个在jvm专题中再分析。

给大家推荐一个可以查看普通java对象的内部布局工具JOL(JAVA )，使用此工具可以查看new出来的一个java对象的内部布局,以及一个普通的java对象占用多少字节。 引入maven依赖

<!-- 查看Java 对象布局、大小工具 --><groupId>org.openjdk.jol</groupId><artifactId>jol-core</artifactId><version>0.10</version>

测试

public static void main(String[] args) {Object obj = new Object();//查看对象内部信息System.out.println(ClassLayout.parseInstance(obj).toPrintable());}

结果：

：偏移地址，单位字节；

SIZE：占用的内存大小，单位为字节；

TYPE ：类型描述，其中 为对象头；

VALUE：对应内存中当前存储的值，二进制32位；

Mark Word的重要属性：

hash： 保存对象的哈希码。运行期间调用.()来计算，延迟计算，并把结果赋值到这里。

age： 保存对象的分代年龄。表示对象被GC的次数，当该次数到达阈值的时候，对象就会转移到老年代。

： 偏向锁标识位。由于无锁和偏向锁的锁标识都是 01，没办法区分，这里引入一位的偏向锁标识位。

lock： 锁状态标识位。区分锁状态，比如11时表示对象待GC回收状态, 只有最后2位 锁标识(11)有效。

*： 保存持有偏向锁的线程ID。偏向模式的时候，当某个线程持有对象的时候，对象这里就会被置为该线程的ID。 在后面的操作中，就无需再进行尝试获取锁的动 作。这个线程ID并不是JVM分配的线程ID号，和Java 中的ID是两个概念。

epoch： 保存偏向时间戳。偏向锁在CAS锁操作过程中，偏向性标识，表示对象更偏 向哪个锁

64位JVM下的对象结构描述

根据上图锁标志位，由于无锁状态和偏向锁都是01，需要额外一位来判断是否是偏向锁。根据上图锁的各种标志位：

无锁的标识：001

偏向锁：101

轻量锁：00

重量锁：10

Mark Word中锁标记枚举：

enum { locked_value             = 0,    //00 轻量级锁 unlocked_value           = 1,   //001 无锁monitor_value            = 2,   //10 监视器锁，也叫膨胀锁，也叫重量级锁marked_value             = 3,   //11 GC标记biased_lock_pattern      = 5    //101 偏向锁

更直观的理解方式：

利用JOL工具跟踪锁标记变化

之前我们测试JOL工具用到的代码

public static void main(String[] args) {Object obj = new Object();//查看对象内部信息System.out.println(ClassLayout.parseInstance(obj).toPrintable());}

结果：

看红框中数字 001 这是就是锁的标志位。对应上面讲到的001代表无锁

上面代码修改成

public static void main(String[] args) {Object obj = new Object();//查看对象内部信息new Thread(()->{synchronized (obj) {System.out.println(Thread.currentThread().getName()+":"+ClassLayout.parseInstance(obj).toPrintable());}},"Thread1").start();}

00代表轻量级锁，后面3个8位就是指向持有锁线程的栈中的锁记录的内存地址。

JDK1.5之后对 进行优化，引入了偏向锁、轻量锁等概念，为什么不是偏向锁呢？

这里有个概念叫做偏向锁延迟解释这个概念之前先来了解什么是偏向锁

偏向锁

偏向锁是一种针对加锁操作的优化手段，经过研究发现，在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，因此为了消除数据在无竞争情况下锁重入（CAS操作）的开销而引入偏向锁。对于没有锁竞争的场合，偏向锁有很好的优化效果。

/***StringBuffer内部同步***/
public synchronized int length() { return count; 
} 
//System.out.println 无意识的使用锁 
public void println(String x) { synchronized (this) {print(x); newLine(); } 

像我们使用的.out.、的方法等里面都包含有 ，为了避免单线程(无竞争情况下)锁性能的开销，引入偏向锁。

偏向锁延迟偏向

偏向锁模式存在偏向锁延迟机制： 虚拟机在启动后有个 4s 的延迟才会对每个新建的对象开启偏向锁模式。JVM启动时会进行一系列的复杂活动，比如装载配置，系统类初始化等 等。在这个过程中会使用大量关键字对对象加锁，且这些锁大多数都不是偏向锁。 为了减少初始化时间，JVM默认延时加载偏向锁。

//关闭延迟开启偏向锁
-XX:BiasedLockingStartupDelay=0
//禁止偏向锁
-XX:-UseBiasedLocking 
//启用偏向锁
-XX:+UseBiasedLocking

我们关闭偏向锁延迟

再次执行上面代码：

现在使用默认的情况下，就是什么jvm参数都不添加的情况下，将上面代码修改在执行

public static void main(String[] args) throws InterruptedException {Thread.sleep(5000);Object obj = new Object();//查看对象内部信息new Thread(()->{synchronized (obj) {System.out.println(Thread.currentThread().getName()+":"+ClassLayout.parseInstance(obj).toPrintable());}},"Thread1").start();}

101就是偏向锁的标识。这就验证了偏向锁延迟。

偏向锁撤销和升级

有一个思考题：如果对象调用了,还会开启偏向锁模式吗？

public static void main(String[] args) throws InterruptedException {Thread.sleep(5000);Object obj = new Object();obj.hashCode();//查看对象内部信息new Thread(()->{synchronized (obj) {System.out.println(Thread.currentThread().getName()+":"+ClassLayout.parseInstance(obj).toPrintable());}},"Thread1").start();}

当锁对象调用了，偏向锁就变成了轻量级锁。为什么参考64位JVM下的对象结构描述图。

调用锁对象的obj.()或.(obj)方法会导致该对象的偏向锁被撤销。因为对于一个对象，其只会生成一次并保存，偏向锁是没有地方保存的

再考虑这么一个情况，上面调用 是在 之前，称之为可偏向状态，如果调用了 称之为已偏向状态。那么如果在已偏向状态的情况下调用 呢？

public static void main(String[] args) throws InterruptedException {Thread.sleep(5000);Object obj = new Object();//查看对象内部信息new Thread(()->{synchronized (obj) {obj.hashCode();
System.out.println(Thread.currentThread().getName()+":"+ClassLayout.parseInstance(obj).toPrintable());}},"Thread1").start();}

偏向锁直接升级为重量级锁。

结论：当对象处于可偏向（也就是线程ID为0）和已偏向的状态下，调用计算将会使对象再也无法偏向：

在看这么一种情况，如果在偏向状态下调用了wait或者又是什么样的情况

public static void main(String[] args) throws InterruptedException {Thread.sleep(5000);Object obj = new Object();//查看对象内部信息new Thread(() -> {synchronized (obj) {try {obj.wait(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + ":" + ClassLayout.parseInstance(obj).toPrintable());}}, "Thread1").start();}

直接升级为重量级锁。之前说过关键字和wait()、()、()都是基于机制实现，所以直接把偏向锁升级为重量级锁。

再来看看()的情况

public static void main(String[] args) throws InterruptedException {Thread.sleep(5000);Object obj = new Object();//查看对象内部信息new Thread(() -> {synchronized (obj) {obj.notify();System.out.println(Thread.currentThread().getName() + ":" + ClassLayout.parseInstance(obj).toPrintable());}}, "Thread1").start();}

调用了()之后把偏向锁升级为轻量级锁。这就奇怪啦为什么wait()方法升级为重量级，()升级轻量级。不知道jvm底层是到底怎么去实现的。

就是当偏向锁消除，升级之后不一定就是轻量锁或者重量级锁。

总结一下什么情况下导致偏向锁消除和升级。

轻量级锁

倘若偏向锁失败，虚拟机并不会立即升级为重量级锁，它还会尝试使用一种称为轻量级锁的优化手段，此时Mark Word 的结构也变为轻量级锁的结构。轻量级锁所适应的场景是线程交替执行同步块的场合，如果存在同一时间多个线程访问同一把锁的场合，就会导致轻量级锁膨胀为重量级锁

package com.tuling.jucdemo.test;import org.openjdk.jol.info.ClassLayout;public class test1 {public static void main(String[] args) throws InterruptedException {Thread.sleep(5000);Object obj = new Object();//查看对象内部信息Thread thread1 = new Thread(() -> {synchronized (obj) {System.out.println(Thread.currentThread().getName() + ":" + ClassLayout.parseInstance(obj).toPrintable());}}, "Thread1");Thread thread2 = new Thread(() -> {synchronized (obj) {System.out.println(Thread.currentThread().getName() + ":" + ClassLayout.parseInstance(obj).toPrintable());}}, "Thread2");thread1.start();thread1.join();thread2.start();thread2.join();System.out.println(Thread.currentThread().getName() + ":" + ClassLayout.parseInstance(obj).toPrintable());}
}

结果：

从偏向锁升级为轻量级锁然后变成无锁。但这不是唯一的结果，多次运行锁的状态不一定是这样。

轻量级锁升级为重量级锁。当多个线程同一时间访问一个资源的时候。

public static void main(String[] args) throws InterruptedException {Thread.sleep(5000);Object obj = new Object();//查看对象内部信息Thread thread1 = new Thread(() -> {synchronized (obj) {System.out.println(Thread.currentThread().getName() + ":" + ClassLayout.parseInstance(obj).toPrintable());}}, "Thread1");Thread thread2 = new Thread(() -> {synchronized (obj) {System.out.println(Thread.currentThread().getName() + ":" + ClassLayout.parseInstance(obj).toPrintable());}}, "Thread2");
thread1.start();
thread2.start();}

还有两个问题：