关于synchronized:java开发技术之synchronized的使用浅析

52次阅读

共计 7809 个字符，预计需要花费 20 分钟才能阅读完成。

synchronized 这个关键字的重要性显而易见，简直能够说是并发、多线程必须会问到的关键字了。synchronized 会波及到锁、降级降级操作、锁的撤销、对象头等。所以了解 synchronized 十分重要，本篇文章就带你从 synchronized 的根本用法、再到 synchronized 的深刻了解，对象头等，为你揭开 synchronized 的面纱。
浅析 synchronized
synchronized 是 Java 并发模块 十分重要的关键字，它是 Java 内建的一种同步机制，代表了某种外在锁定的概念，当一个线程对某个共享资源加锁后，其余想要获取共享资源的线程必须进行期待，synchronized 也具备互斥和排他的语义。
什么是互斥？咱们想必小时候都玩儿过磁铁，磁铁会有正负极的概念，同性相斥异性相吸，相斥相当于就是一种互斥的概念，也就是两者互不相容。

synchronized 也是一种独占的关键字，然而它这种独占的语义更多的是为了减少线程安全性，通过独占某个资源以达到互斥、排他的目标。
在理解了排他和互斥的语义后，咱们先来看一下 synchronized 的用法，先来理解用法，再来理解底层实现。
synchronized 的应用
对于 synchronized 想必你应该都大抵理解过
• synchronized 润饰实例办法，相当于是对类的实例进行加锁，进入同步代码前须要取得以后实例的锁
• synchronized 润饰静态方法，相当于是对类对象进行加锁
• synchronized 润饰代码块，相当于是给对象进行加锁，在进入代码块前须要先取得对象的锁

上面咱们针对每个用法进行解释
synchronized 润饰实例办法
synchronized 润饰实例办法，实例办法是属于类的实例。synchronized 润饰的实例办法相当于是对象锁。上面是一个 synchronized 润饰实例办法的例子。
public synchronized void method()
{
// …
}
像如上述 synchronized 润饰的办法就是实例办法，上面咱们通过一个残缺的例子来认识一下 synchronized 润饰实例办法
public class TSynchronized implements Runnable{

static int i = 0;

public synchronized void increase(){
    i++;
    System.out.println(Thread.currentThread().getName());
}


@Override
public void run() {for(int i = 0;i < 1000;i++) {increase();
    }
}

public static void main(String[] args) throws InterruptedException {TSynchronized tSynchronized = new TSynchronized();
    Thread aThread = new Thread(tSynchronized);
    Thread bThread = new Thread(tSynchronized);
    aThread.start();
    bThread.start();
    aThread.join();
    bThread.join();
    System.out.println("i =" + i);
}

}
下面输入的后果 i = 2000，并且每次都会打印以后现成的名字
来解释一下下面代码，代码中的 i 是一个动态变量，动态变量也是全局变量，动态变量存储在办法区中。increase 办法由 synchronized 关键字润饰，然而没有应用 static 关键字润饰，示意 increase 办法是一个实例办法，每次创立一个 TSynchronized 类的同时都会创立一个 increase 办法，increase 办法中只是打印进去了以后拜访的线程名称。Synchronized 类实现了 Runnable 接口，重写了 run 办法，run 办法外面就是一个 0 – 1000 的计数器，这个没什么好说的。在 main 办法中，new 出了两个线程，别离是 aThread 和 bThread，Thread.join 示意期待这个线程解决完结。这段代码次要的作用就是判断 synchronized 润饰的办法可能具备独占性。
synchronized 润饰静态方法
synchronized 润饰静态方法就是 synchronized 和 static 关键字一起应用
public static synchronized void increase(){}
当 synchronized 作用于静态方法时，java 培训示意的就是以后类的锁，因为静态方法是属于类的，它不属于任何一个实例成员，因而能够通过 class 对象管制并发拜访。
这里须要留神一点，因为 synchronized 润饰的实例办法是属于实例对象，而 synchronized 润饰的静态方法是属于类对象，所以调用 synchronized 的实例办法并不会阻止拜访 synchronized 的静态方法。

synchronized 润饰代码块
synchronized 除了润饰实例办法和静态方法外，synchronized 还可用于润饰代码块，代码块能够嵌套在办法体的外部应用。
public void run() {
synchronized(obj){

for(int j = 0;j < 1000;j++){i++;}

}
}
下面代码中将 obj 作为锁对象对其加锁，每次当线程进入 synchronized 润饰的代码块时就会要求以后线程持有 obj 实例对象锁，如果以后有其余线程正持有该对象锁，那么新到的线程就必须期待。
synchronized 润饰的代码块，除了能够锁定对象之外，也能够对以后实例对象锁、class 对象锁进行锁定
// 实例对象锁
synchronized(this){

for(int j = 0;j < 1000;j++){i++;}

}

//class 对象锁
synchronized(TSynchronized.class){

for(int j = 0;j < 1000;j++){i++;}

}
synchronized 底层原理
在简略介绍完 synchronized 之后，咱们就来聊一下 synchronized 的底层原理了。
咱们或者都有所理解（下文会粗疏剖析），synchronized 的代码块是由一组 monitorenter/monitorexit 指令实现的。而 Monitor 对象是实现同步的根本单元。

Monitor 对象
任何对象都关联了一个管程，管程就是管制对象并发拜访的一种机制。管程 是一种同步原语，在 Java 中指的就是 synchronized，能够了解为 synchronized 就是 Java 中对管程的实现。
管程提供了一种排他拜访机制，这种机制也就是 互斥。互斥保障了在每个工夫点上，最多只有一个线程会执行同步办法。
所以你了解了 Monitor 对象其实就是应用管程管制同步拜访的一种对象。
对象内存布局
在 hotspot 虚拟机中，对象在内存中的布局分为三块区域：
• 对象头(Header)
• 实例数据(Instance Data)
• 对齐填充(Padding)

这三块区域的内存散布如下图所示

咱们来具体介绍一下下面对象中的内容。
对象头 Header
对象头 Header 次要蕴含 MarkWord 和对象指针 Klass Pointer，如果是数组的话，还要蕴含数组的长度。

在 32 位的虚拟机中 MarkWord，Klass Pointer 和数组长度别离占用 32 位，也就是 4 字节。
如果是 64 位虚拟机的话，MarkWord，Klass Pointer 和数组长度别离占用 64 位，也就是 8 字节。
在 32 位虚拟机和 64 位虚拟机的 Mark Word 所占用的字节大小不一样，32 位虚拟机的 Mark Word 和 Klass Pointer 别离占用 32 bits 的字节，而 64 位虚拟机的 Mark Word 和 Klass Pointer 占用了 64 bits 的字节，上面咱们以 32 位虚拟机为例，来看一下其 Mark Word 的字节具体是如何调配的。

用中文翻译过去就是

• 无状态也就是无锁的时候，对象头开拓 25 bit 的空间用来存储对象的 hashcode，4 bit 用于寄存分代年龄，1 bit 用来寄存是否偏差锁的标识位，2 bit 用来寄存锁标识位为 01。
• 偏差锁 中划分更细，还是开拓 25 bit 的空间，其中 23 bit 用来寄存线程 ID，2bit 用来寄存 epoch，4bit 寄存分代年龄，1 bit 寄存是否偏差锁标识，0 示意无锁，1 示意偏差锁，锁的标识位还是 01。
• 轻量级锁中间接开拓 30 bit 的空间寄存指向栈中锁记录的指针，2bit 寄存锁的标记位，其标记位为 00。
• 重量级锁中和轻量级锁一样，30 bit 的空间用来寄存指向重量级锁的指针，2 bit 寄存锁的标识位，为 11
• GC 标记开拓 30 bit 的内存空间却没有占用，2 bit 空间寄存锁标记位为 11。

其中无锁和偏差锁的锁标记位都是 01，只是在后面的 1 bit 辨别了这是无锁状态还是偏差锁状态。
对于为什么这么调配的内存，咱们能够从 OpenJDK 中的 markOop.hpp 类中的枚举窥出端倪

来解释一下
• age_bits 就是咱们说的分代回收的标识，占用 4 字节
• lock_bits 是锁的标记位，占用 2 个字节
• biased_lock_bits 是是否偏差锁的标识，占用 1 个字节。
• max_hash_bits 是针对无锁计算的 hashcode 占用字节数量，如果是 32 位虚拟机，就是 32 – 4 – 2 -1 = 25 byte，如果是 64 位虚拟机，64 – 4 – 2 – 1 = 57 byte，然而会有 25 字节未应用，所以 64 位的 hashcode 占用 31 byte。
• hash_bits 是针对 64 位虚拟机来说，如果最大字节数大于 31，则取 31，否则取实在的字节数
• cms_bits 我感觉应该是不是 64 位虚拟机就占用 0 byte，是 64 位就占用 1byte
• epoch_bits 就是 epoch 所占用的字节大小，2 字节。

在下面的虚拟机对象头调配表中，咱们能够看到有几种锁的状态：无锁（无状态），偏差锁，轻量级锁，重量级锁，其中轻量级锁和偏差锁是 JDK1.6 中对 synchronized 锁进行优化后新减少的，其目标就是为了大大优化锁的性能，所以在 JDK 1.6 中，应用 synchronized 的开销也没那么大了。其实从锁有无锁定来讲，还是只有无锁和重量级锁，偏差锁和轻量级锁的呈现就是减少了锁的获取性能而已，并没有呈现新的锁。
所以咱们的重点放在对 synchronized 重量级锁的钻研上，当 monitor 被某个线程持有后，它就会处于锁定状态。在 HotSpot 虚拟机中，monitor 的底层代码是由 ObjectMonitor 实现的，其次要数据结构如下（位于 HotSpot 虚拟机源码 ObjectMonitor.hpp 文件，C++ 实现的）

这段 C++ 中须要留神几个属性：_WaitSet、_EntryList 和 _Owner，每个期待获取锁的线程都会被封装称为 ObjectWaiter 对象。

_Owner 是指向了 ObjectMonitor 对象的线程，而 _WaitSet 和 _EntryList 就是用来保留每个线程的列表。
那么这两个列表有什么区别呢？这个问题我和你聊一下锁的获取流程你就分明了。

锁的两个列表
当多个线程同时拜访某段同步代码时，首先会进入 _EntryList 汇合，当线程获取到对象的 monitor 之后，就会进入 _Owner 区域，并把 ObjectMonitor 对象的 _Owner 指向为以后线程，并使 _count + 1，如果调用了开释锁（比方 wait）的操作，就会开释以后持有的 monitor，owner = null，_count – 1，同时这个线程会进入到 _WaitSet 列表中期待被唤醒。如果以后线程执行结束后也会开释 monitor 锁，只不过此时不会进入 _WaitSet 列表了，而是间接复位 _count 的值。

Klass Pointer 示意的是类型指针，也就是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。
你可能不是很了解指针是个什么概念，你能够简略了解为指针就是指向某个数据的地址。


实例数据 Instance Data
实例数据局部是对象真正存储的无效信息，也是代码中定义的各个字段的字节大小，比方一个 byte 占 1 个字节，一个 int 占用 4 个字节。
对齐 Padding
对齐不是必须存在的，它只起到了占位符 (%d, %c 等) 的作用。这就是 JVM 的要求了，因为 HotSpot JVM 要求对象的起始地址必须是 8 字节的整数倍，也就是说对象的字节大小是 8 的整数倍，不够的须要应用 Padding 补全。
锁的降级流程
先来个大体的流程图来感受一下这个过程，而后上面咱们再离开来说

无锁
无锁状态，无锁即没有对资源进行锁定，所有的线程都能够对同一个资源进行拜访，然而只有一个线程可能胜利批改资源。

无锁的特点就是在循环内进行批改操作，线程会一直的尝试批改共享资源，直到可能胜利批改资源并退出，在此过程中没有呈现抵触的产生，这很像咱们在之前文章中介绍的 CAS 实现，CAS 的原理和利用就是无锁的实现。无锁无奈全面代替有锁，但无锁在某些场合下的性能是十分高的。
偏差锁
HotSpot 的作者通过钻研发现，大多数状况下，锁不仅不存在多线程竞争，还存在锁由同一线程屡次取得的状况，偏差锁就是在这种状况下呈现的，它的呈现是为了解决只有在一个线程执行同步时进步性能。

能够从对象头的调配中看到，偏差锁要比无锁多了线程 ID 和 epoch，上面咱们就来形容一下偏差锁的获取过程
偏差锁获取过程

  1. 首先线程拜访同步代码块，会通过查看对象头 Mark Word 的锁标记位判断目前锁的状态，如果是 01，阐明就是无锁或者偏差锁，而后再依据是否偏差锁 的标示判断是无锁还是偏差锁，如果是无锁状况下，执行下一步
  2. 线程应用 CAS 操作来尝试对对象加锁，如果应用 CAS 替换 ThreadID 胜利，就阐明是第一次上锁，那么以后线程就会取得对象的偏差锁，此时会在对象头的 Mark Word 中记录以后线程 ID 和获取锁的工夫 epoch 等信息，而后执行同步代码块。

全局平安点（Safe Point）：全局平安点的了解会波及到 C 语言底层的一些常识，这里简略了解 SafePoint 是 Java 代码中的一个线程可能暂停执行的地位。

等到下一次线程在进入和退出同步代码块时就不须要进行 CAS 操作进行加锁和解锁，只须要简略判断一下对象头的 Mark Word 中是否存储着指向以后线程的线程 ID，判断的标记当然是依据锁的标记位来判断的。如果用流程图来示意的话就是上面这样

敞开偏差锁
偏差锁在 Java 6 和 Java 7 里是默认启用的。因为偏差锁是为了在只有一个线程执行同步块时进步性能，如果你确定应用程序里所有的锁通常状况下处于竞争状态，能够通过 JVM 参数敞开偏差锁：-XX:-UseBiasedLocking=false，那么程序默认会进入轻量级锁状态。
对于 epoch
偏差锁的对象头中有一个被称为 epoch 的值，它作为偏差有效性的工夫戳。
轻量级锁
轻量级锁是指以后锁是偏差锁的时候，资源被另外的线程所拜访，那么偏差锁就会降级为轻量级锁，其余线程会通过自旋的模式尝试获取锁，不会阻塞，从而进步性能，上面是具体的获取过程。
轻量级锁加锁过程

  1. 紧接着上一步，如果 CAS 操作替换 ThreadID 没有获取胜利，执行下一步
  2. 如果应用 CAS 操作替换 ThreadID 失败（这时候就切换到另外一个线程的角度）阐明该资源已被同步拜访过，这时候就会执行锁的撤销操作，撤销偏差锁，而后等原持有偏差锁的线程达到全局平安点（SafePoint）时，会暂停原持有偏差锁的线程，而后会查看原持有偏差锁的状态，如果曾经退出同步，就会唤醒持有偏差锁的线程，执行下一步
  3. 查看对象头中的 Mark Word 记录的是否是以后线程 ID，如果是，执行同步代码，如果不是，执行偏差锁获取流程 的第 2 步。

如果用流程示意的话就是上面这样（曾经蕴含偏差锁的获取）

重量级锁
重量级锁其实就是 synchronized 最终加锁的过程，在 JDK 1.6 之前，就是由无锁 -> 加锁的这个过程。
重量级锁的获取流程

  1. 接着下面偏差锁的获取过程，由偏差锁降级为轻量级锁，执行下一步
  2. 会在原持有偏差锁的线程的栈中调配锁记录，将对象头中的 Mark Word 拷贝到原持有偏差锁线程的记录中，原持有偏差锁的线程取得轻量级锁，而后唤醒原持有偏差锁的线程，从平安点处继续执行，执行结束后，执行下一步，以后线程执行第 4 步
  3. 执行结束后，开始轻量级解锁操作，解锁须要判断两个条件

• 判断对象头中的 Mark Word 中锁记录指针是否指向以后栈中记录的指针

• 拷贝在以后线程锁记录的 Mark Word 信息是否与对象头中的 Mark Word 统一。

如果下面两个判断条件都合乎的话，就进行锁开释，如果其中一个条件不合乎，就会开释锁，并唤起期待的线程，进行新一轮的锁竞争。

  1. 在以后线程的栈中调配锁记录，拷贝对象头中的 MarkWord 到以后线程的锁记录中，执行 CAS 加锁操作，会把对象头 Mark Word 中锁记录指针指向以后线程锁记录，如果胜利，获取轻量级锁，执行同步代码，而后执行第 3 步，如果不胜利，执行下一步
  2. 以后线程没有应用 CAS 胜利获取锁，就会自旋一会儿，再次尝试获取，如果在屡次自旋达到下限后还没有获取到锁，那么轻量级锁就会降级为 重量级锁

如果用流程图示意是这样的

依据下面对于锁降级粗疏的形容，咱们能够总结一下不同锁的适用范围和场景。

synchronized 代码块的底层实现
为了便于不便钻研，咱们把 synchronized 润饰代码块的示例简单化，如下代码所示
public class SynchronizedTest {

private int i;

public void syncTask(){synchronized (this){i++;}
}

}
咱们次要关注一下 synchronized 的字节码，如下所示

从这段字节码中咱们能够晓得，同步语句块应用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始地位，monitorexit 指令指向同步代码块的完结地位。
那么为什么会有两个 monitorexit 呢？

不晓得你留神到上面的异样表了吗？如果你不晓得什么是异样表，那么我倡议你读一下这篇文章
看完这篇 Exception 和 Error，和面试官扯皮就没问题了
synchronized 润饰办法的底层原理
办法的同步是隐式的，也就是说 synchronized 润饰办法的底层无需应用字节码来管制，真的是这样吗？咱们来反编译一波看看后果
public class SynchronizedTest {

private int i;

public synchronized void syncTask(){i++;}

}
这次咱们应用 javap -verbose 来输入具体的后果

从字节码上能够看出，synchronized 润饰的办法并没有应用 monitorenter 和 monitorexit 指令，获得代之是 ACC_SYNCHRONIZED 标识，该标识指明了此办法是一个同步办法，JVM 通过该 ACC_SYNCHRONIZED 拜访标记来分别一个办法是否申明为同步办法，从而执行相应的同步调用。这就是 synchronized 锁在同步代码块上和同步办法上的实现差异。
作者 cxuan

正文完
synchronized
发表至： synchronized
2021-09-29
 0
关于synchronized:synchronized-是王的后宫总管线程是王妃
关于synchronized:Synchronized锁及其膨胀
关于synchronized:13张图深入理解Synchronized
关于synchronized:验证synchronized锁升级时对象头变化全过程-springboot实战电商项目mall4j