关于多线程:synchronized用法原理和锁优化升级过程面试

简介

多线程始终是面试中的重点和难点，无论你当初处于啥级别段位，对synchronized关键字的学习防止不了，这是我的心得体会。上面咱们以面试的思维来对synchronized做一个零碎的形容，如果有面试官问你，说说你对synchronized的了解？你能够从synchronized应用层面，synchronized的JVM层面，synchronized的优化层面3个方面做零碎答复，说不定面试官会对你另眼相看哦！文章会有大量的代码是不便了解的，如果你有工夫肯定要入手敲下加深了解和记忆。如果这篇文章能对您能有所帮忙是我创作路上最大快慰。

synchronized应用层面

大家都晓得synchronized是一把锁，锁到底是什么呢？举个例子，你能够把锁了解为厕所门上那把锁的惟一钥匙，每个人要进去只能拿着这把钥匙能够去开这个厕所的门，这把钥匙在一时刻只能有一个人领有，有钥匙的人能够重复出入厕所，在程序中咱们叫做这种反复出入厕所行为叫锁的可重入。它能够润饰静态方法，实例办法和代码块，那上面咱们一起来看看synchronized用于同步代码锁表白的意思。

对于一般同步办法，锁的是对象实例。
对于动态同步办法，锁的是类的Class对象。
对于同步代码块，锁的是括号中的对象。

先说下同步和异步的概念。

同步：交替执行。
异步：同时执行。

举个例子比方吃饭和看电视两件事件，先吃完饭后再去看电视，在工夫维度上这两件事是有先后顺序的，叫同步。能够一边吃饭，一边看刷剧，在工夫维度上是不分先后同时进行的，饭吃完了电视也看了，就能够去学习了，这就是异步，异步的益处是能够提高效率，这样你就能够节省时间去学习了。

上面咱们看看代码，代码中有做了很具体的正文，能够复制到本地进行测试。如果有synchronized根底的童鞋，能够跳过锁应用层面的解说。

/** * @author ：jiaolian * @date ：Created in 2020-12-17 14:48 * @description：测试静态方法同步和一般办法同步是不同的锁,包含synchronized润饰的动态代码块用法; * @modified By： * 公众号:叫练 */public class SyncTest {    public static void main(String[] args) {        Service service = new Service();        /**         * 启动上面4个线程，别离测试m1-m4办法。         */        Thread threadA = new Thread(() -> Service.m1());        Thread threadB = new Thread(() -> Service.m2());        Thread threadC = new Thread(() -> service.m3());        Thread threadD = new Thread(() -> service.m4());        threadA.start();        threadB.start();        threadC.start();        threadD.start();    }    /**     * 此案例阐明了synchronized润饰的静态方法和一般办法获取的不是同一把锁，因为他们是异步的，相当于是同步执行;     */    private static class Service {        /**         * m1办法synchronized润饰静态方法，锁示意锁定的是Service.class         */        public synchronized static void m1() {            System.out.println("m1 getlock");            try {                Thread.sleep(2000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("m1 releaselock");        }        /**         * m2办法synchronized润饰静态方法，锁示意锁定的是Service.class         * 当线程AB同时启动，m1和m2办法是同步的。能够证实m1和m2是同一把锁。         */        public synchronized static void m2() {            System.out.println("m2 getlock");            System.out.println("m2 releaselock");        }        /**         * m3办法synchronized润饰的一般办法，锁示意锁定的是Service service = new Service();中的service对象；         */        public synchronized void m3() {            System.out.println("m3 getlock");            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("m3 releaselock");        }        /**         * 1.m4办法synchronized润饰的同步代码块，锁示意锁定的是以后对象实例,也就是Service service = new Service();中的service对象；和m3一样，是同一把锁；         * 2.当线程CD同时启动，m3和m4办法是同步的。能够证实m3和m4是同一把锁。         * 3.synchronized也能够润饰其余对象，比方synchronized (Service.class),此时m4,m1,m2办法是同步的，启动线程ABD能够证实。         */        public void m4() {            synchronized (this) {                System.out.println("m4 getlock");                System.out.println("m4 releaselock");            }        }    }}

通过下面的测试，你能够能会有疑难，锁既然是存在的，那它存储在什么中央？答案：对象外面。上面咱们用代码来证实下。

锁在对象头外面，一个对象包含对象头，实例数据和对齐填充。对象头包含MarkWord和对象指针，对象指针是指向办法区的对象类型的，，实例对象就是属性数据，一个对象可能有很多属性，属性是动静的。对齐填充是为了补齐字节数的，如果对象大小不是8字节的整数倍，须要补齐残余的字节数，这是不便计算机来计算的。在64位机器外面，一个对象的对象头个别占12个本人大小，在64位操作系统个别占4个字节，所以MarkWord就是8个字节了。

MarkWord包含对象hashcode，偏差锁标记位，线程id和锁的标识。为了不便测试对象头的内容，须要引入maven openjdk的依赖包。

<dependency>  <groupId>org.openjdk.jol</groupId>  <artifactId>jol-core</artifactId>  <version>0.10</version></dependency>

/** * @author ：duyang * @date ：Created in 2020-05-14 20:21 * @description：对象占用内存 * @modified By： * *  Fruit对象头是12字节（markword+class） *  int 占4个字节 * *  32位机器可能占8个字节; * *  Object对象头12 对齐填充4 一共是16 */public class ObjectMemory {    public static void main(String[] args) {        //System.out.print(ClassLayout.parseClass(Fruit.class).toPrintable());        System.out.print(ClassLayout.parseInstance(Fruit.class).toPrintable());    }}/** *Fruit 测试类 */public class Fruit {    //占一个字节大小    private boolean flag;}

测试后果：上面画红线的3行别离示意对象头，实例数据和对齐填充。对象头是12个字节，实例数据Fruit对象的一个boolean字段flag占1个字节大小，其余3个字节是对齐填充的局部，一共是16个字节大小。

咦？你说的锁呢，怎么没有看到呢？小伙，别着急，待会咱们讲到synchronized降级优化层面的时候再来详细分析一波。上面咱们先剖析下synchronized在JVM层面的意思。

最初上图文总结：

synchronized JVM层面

/** * @author ：jiaolian * @date ：Created in 2020-12-20 13:43 * @description：锁的jvm层面应用 * @modified By： * 公众号:叫练 */public class SyncJvmTest {    public static void main(String[] args) {        synchronized (SyncJvmTest.class) {            System.out.println("jvm同步测试");        }    }}

下面的案例中，咱们同步代码块中咱们简略输入一句话，咱们次要看看jvm中它是怎么实现的。咱们用Javap -v SyncJvmTest.class反编译出下面的代码，如下图所示。

上图第一行有一个monitorenter和第六行一个monitorexit，两头的jvm指令（2-5行）对应的Java代码中的main办法的代码，synchronized就是依赖于这两个指令实现。咱们来看看JVM标准中monitorenter语义。

每个对象都有一把锁，当一个线程进入同步代码块，都会去获取这个对象所持有monitor对象锁（C++实现），如果以后线程获取锁，会把monitor对象进入数自增1次。
如果该线程反复进入，会把monitor对象进入数再次自增1次。
当有其余线程进入，会把其余线程放入期待队列排队，直到获取锁的线程将monitor对象的进入数设置为0开释锁，其余线程才有机会获取锁。

synchronized的优化层面

synchronized是一个重量级锁，次要是因为线程竞争锁会引起操作系统用户态和内核态切换，浪费资源效率不高，在jdk1.5之前，synchronized没有做任何优化，但在jdk1.6做了性能优化，它会经验偏差锁，轻量级锁，最初才到重量级锁这个过程，在性能方面有了很大的晋升，在jdk1.7的ConcurrentHashMap是基于ReentrantLock的实现了锁，但在jdk1.8之后又替换成了synchronized，就从这一点能够看出JVM团队对synchronized的性能还是挺有信念的。上面咱们别离来介绍下无锁，偏差锁，轻量级锁，重量级锁。上面咱们我画张图来形容这几个级别锁的在对象头存储状态。如图所示。

无锁。如果不加synchronized关键字，示意无锁，很好了解。
偏差锁。
降级过程：当线程进入同步块时，Markword会存储偏差线程的id并且cas将Markword锁状态标识为01，是否偏差用1示意以后处于偏差锁（对着上图来看），如果是偏差线程下次进入同步代码只有比拟Markword的线程id是否和以后线程id相等，如果相等不必做任何操作就能够进入同步代码执行，如果不比拟后不相等阐明有其余线程竞争锁，synchronized会升级成轻量级锁。这个过程中在操作系统层面不必做内核态和用户态的切换，缩小切换线程带来的资源耗费。
收缩过程：当有另外线程进入，偏差锁会升级成轻量级锁。比方线程A是偏差锁，这是B线程进入，就会成轻量级锁，只有有两个线程就会升级成轻量级锁。

上面咱们代码来看下偏差锁的锁状态。

package com.duyang.base.basic.markword;import lombok.SneakyThrows;import org.openjdk.jol.info.ClassLayout;/** * @author ：jiaolian * @date ：Created in 2020-12-19 11:25 * @description：markword测试 * @modified By： * 公众号:叫练 */public class MarkWordTest {    private static Fruit fruit = new Fruit();    public static void main(String[] args) throws InterruptedException {        Task task = new Task();        Thread threadA = new Thread(task);        Thread threadB = new Thread(task);        Thread threadC = new Thread(task);        threadA.start();        //threadA.join();        //threadB.start();        //threadC.start();    }    private static class Task extends Thread {        @SneakyThrows        @Override        public void run() {            synchronized (fruit) {                System.out.println("==================="+Thread.currentThread().getId()+" ");                try {                    Thread.sleep(3000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.print(ClassLayout.parseInstance(fruit).toPrintable());            }        }    }}

下面代码启动线程A，控制台输入如下图所示，红色标记3个bit是101别离示意，高位的1示意是偏差锁，01是偏差锁标识位。合乎偏差锁标识的状况。

轻量级锁。
降级过程：在线程运行获取锁后，会在栈帧中发明锁记录并将MarkWord复制到锁记录，而后将MarkWord指向锁记录，如果以后线程持有锁，其余线程再进入，此时其余线程会cas自旋，直到获取锁，轻量级锁适宜多线程交替执行，效率高（cas只耗费cpu，我在cas原理一篇文章中具体讲过。）。
收缩过程：有两种状况会收缩成重量级锁。1种状况是cas自旋10次还没获取锁。第2种状况其余线程正在cas获取锁，第三个线程竞争获取锁，锁也会收缩变成重量级锁。

上面咱们代码来测试下轻量级锁的锁状态。

关上23行-24行代码，执行线程A，B，我的目标是程序执行线程A B ，所以我在代码中先执行threadA.join()，让A线程先执行结束，再执行B线程，如下图所示MarkWord锁状态变动，线程A开始是偏差锁用101示意，执行线程B就变成轻量级锁了，锁状态变成了00，合乎轻量级锁锁状态。证实结束。

重量级锁。重量级锁降级后是不可逆的，也就是说分量锁不能够再变为轻量级锁。

关上25行代码，执行线程A，B，C，我的目标是先执行线程A，在代码中先执行threadA.join()，让A线程先执行结束，而后再同时执行线程BC ，如下图所示看看MarkWord锁状态变动，线程A开始是偏差锁，到同时执行线程BC，因为有强烈竞争，属于轻量级锁收缩条件第2种状况，当其余线程正在cas获取锁，第三个线程竞争获取锁，锁也会收缩变成重量级锁。此时BC线程锁状态都变成了10，这种状况合乎重量级锁锁状态。收缩重量级锁证实结束。

到此为止，咱们曾经把synchronized锁降级过程中的锁状态通过代码的模式都证实了一遍，心愿对你有帮忙。下图是本人总结。

总结

多线程synchronized始终是个很重要的话题，也是面试中常见的考点。心愿大家都能尽快了解把握，分享给你们心愿你们喜爱！

我是叫练，多叫多练，欢送大家和我一起探讨交换，我会尽快回复大家，喜爱点赞和关注哦！公众号【叫练】。