synchronized原理

蔚落 2024-03-27 14:25 11阅读 0赞

![4e33ae1c68c51a0a3dbc2deb7e141702.png][]

一.锁升级

synchronized相对比较‘智能’，会根据锁竞争的激烈程度进行锁升级，其锁升级策略如下：

![8f42c1513beb13652cfa335a3fe241e3.png][]

我们一一对一下四种上锁情况进行分析：

1.  无锁：锁对象没有锁竞争时，synchronized并不会进行上锁操作，无锁状态是理论上会存在的状态，但是在实际业务场景中几乎不存在

1.  偏向锁：偏向锁并不是真正的加锁，而是对锁对象进行加‘标签’的操作，这个标签记录哪个线程调用了这把锁，如果后续没有其他线程来调用这把锁，就一直保持偏向锁的状态，如果后面有其他线程同样竞争这把锁，那么只需要将标签中的线程与该线程进行对比，如果不一致，则有偏向锁转化为轻量级锁。偏向锁在本质上是延迟加锁的操作：能不加锁就不加锁，尽量避免不必要的加锁开销。

1.  轻量级锁：当有其他线程对这把锁进行锁竞争，偏向锁的锁状态就会被解除，进入轻量级锁，在这里轻量级锁是自适应的自旋锁（通过CAS来实现）：通过CAS检查并更新所资源的调用情况，如果更新成功，则加锁成功，更新失败认为锁被占用，不断进行自旋等待（并不放弃cpu）,但是不断的自旋是会消耗内存，一般自旋一定的次数和时间就不再自旋了，这就是所谓的‘自适应’。

1.  重量级锁：当锁竞争进一步加强时，轻量级锁就会转化为重量级锁，而重量级锁获取锁的过程如下：首先从用户态进入内核态，判断锁资源是否被占用，没有被占用则进行加锁操作，加锁成功后返回用户态，如果被占用该线程就进入锁的等待队列，当锁资源被释放之后，经过一些列沧海桑田（不及时），这时操作系统才考虑到被挂起的线程，这时才将该线程唤醒，进行加锁操作。

我们举生活中的一个例子对这四种锁状态进行说明：

![a8ece6361d65c78b5beadce822eb4244.png][]

我们通过代码对四种锁状态进行解释：

import org.openjdk.jol.info.ClassLayout;
    
    public class Demo_404_Layout {
        // 定义一些变量
        private int count;
        private long count1 = 200;
        private String hello = "";
        // 定义一个对象变量
        private TestLayout test001 = new TestLayout();
    
        public static void main(String[] args) throws InterruptedException {
            // 创建一个对象的实例
            Object obj = new Object();
            // 打印实例布局
            System.out.println("=== 任意Object对象布局，起初为无锁状态");
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
            synchronized (obj) {
                System.out.println("==== 第一层synchronized加锁后");
                System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    
                System.out.println("=== 延时4S开启偏向锁");
                // 延时4S开启偏向锁
                Thread.sleep(5000);
                // 创建本类的实例
                Demo_404_Layout monitor = new Demo_404_Layout();
                // 打印实例布局，注意查看锁状态为偏向锁
                System.out.println("=== 打印实例布局，注意查看锁状态为偏向锁");
                System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
    
                System.out.println("==== synchronized加锁");
                // 加锁后观察加锁信息
                synchronized (monitor) {
                    System.out.println("==== 第一层synchronized加锁后");
                    System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
                    // 锁重入，查看锁信息
                    synchronized (monitor) {
                        System.out.println("==== 第二层synchronized加锁后，锁重入");
                        System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
                    }
                    // 释放里层的锁
                    System.out.println("==== 释放内层锁后");
                    System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
                }
                // 释放所有锁之后
                System.out.println("==== 释放 所有锁");
                System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
    
                System.out.println("==== 多个线程参与锁竞争，观察锁状态");
                Thread thread1 = new Thread(() -> {
                    synchronized (monitor) {
                        System.out.println("=== 在线程A 中获取锁，参与锁竞争，当前只有线程A 竞争锁，轻度锁竞争");
                        System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
                    }
                });
                thread1.start();
    
                // 休眠一会，不与线程A 激烈竞争
                Thread.sleep(100);
                Thread thread2 = new Thread(() -> {
                    synchronized (monitor) {
                        System.out.println("=== 在线程B 中获取锁，与其他线程进行锁竞争");
                        System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
                    }
                });
                thread2.start();
    
                // 不休眠直接竞争锁，产生激烈竞争
                System.out.println("==== 不休眠直接竞争锁，产生激烈竞争");
                synchronized (monitor) {
                    // 加锁后的类对象
                    System.out.println("==== 与线程B 产生激烈的锁竞争，观察锁状态为fat lock");
                    System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
                }
                // 休眠一会释放锁后
                Thread.sleep(100);
                System.out.println("==== 释放锁后");
                System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
    
                System.out.println("===========================================================================================");
                System.out.println("===========================================================================================");
                System.out.println("===========================================================================================");
                System.out.println("===========================================================================================");
                System.out.println("===========================================================================================");
                System.out.println("===========================================================================================");
    
                // 调用hashCode后才保存hashCode的值
                monitor.hashCode();
                // 调用hashCode后观察现象
                System.out.println("==== 调用hashCode后查看hashCode的值");
                System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
                // 强制执行垃圾回收
                System.gc();
                // 观察GC计数
                System.out.println("==== 调用GC后查看age的值");
                System.out.println(ClassLayout.parseInstance(monitor).toPrintable());
                // 打印类布局，注意调用的方法不同
                System.out.println("==== 查看类布局");
                System.out.println(ClassLayout.parseClass(Demo_404_Layout.class).toPrintable());
                // 打印类对象布局
                System.out.println("==== 查看类对象布局");
                System.out.println(ClassLayout.parseInstance(Demo_404_Layout.class).toPrintable());
    
    
            }
        }
    }

![cb4887119c74fb1301244fa461863fd8.png][]

![e03845a13014e76a58718e22b1c7e24d.png][]

![d0ac83e9c78d3361e5a8b5c822c19e51.png][]

![720dea4b895ad2461baad35a270e6c4c.png][]

![dd1e4d440886469d64df9c29ec99d212.png][]

![a5187dcdf9acb8df37c67c1706a85043.png][]

![06b18decff4ae7d1a0f09b854ca35fcf.png][]

![aa3cdc1254c153a4b15c7ace226b9a75.png][]

![7812f99980e288089f6f59258c4438be.png][]

二.锁消除

锁消除是synchronized的一种优化策略，是编译器+JVM判断锁是否能够消除，如果能够消除就直接消除了

比如以下场景：当我们对变量进行修改时，将修改的代码块加上了synchronized，但是是在单线程的情况下，不存在线程安全问题，这时JVM直接将锁消除了

需要注意的是：只有JVM百分百确定不存在线程安全问题时，才会执行锁消除

另外一种场景：虽然JVM没办法决定在哪个地方加锁（程序员决定），但是如果是在多线程情况下的读操作，就不存在线程安全问题，所以这JVM直接将锁消除了

三.锁粗化

当在一段代码中出现多次加锁和释放锁的操作，这时候JVM会对锁自动进行锁的粗化，避免了锁的多次获取和释放

![21b223d6cab3ce3fbc52d6753978e4ab.png][]

[4e33ae1c68c51a0a3dbc2deb7e141702.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/7e497dae407344bcbd21074d12152581.png
[8f42c1513beb13652cfa335a3fe241e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f3276f16b088484ca178aef61fb4a2f6.png
[a8ece6361d65c78b5beadce822eb4244.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/07b98dbe1ae94d4d88a06ed362ad183a.png
[cb4887119c74fb1301244fa461863fd8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/64e4fc762be349cdbbfa6bbf86cfe6c0.png
[e03845a13014e76a58718e22b1c7e24d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/4d7d77db00ef4328b1a769777c28cb49.png
[d0ac83e9c78d3361e5a8b5c822c19e51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/6c768cfc7e7f471f826eae979c6ddab3.png
[720dea4b895ad2461baad35a270e6c4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d4fb4e1fa9aa4c19be6a0df7f0c94b64.png
[dd1e4d440886469d64df9c29ec99d212.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/74f52f0567fc4a14ad7bca0ace2547eb.png
[a5187dcdf9acb8df37c67c1706a85043.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/46babae8885e4752ab3d7be2f425c953.png
[06b18decff4ae7d1a0f09b854ca35fcf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/fcdd77fb15534ab8870417534aebb59b.png
[aa3cdc1254c153a4b15c7ace226b9a75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/65bef17f8c3e4808892119881e02f1be.png
[7812f99980e288089f6f59258c4438be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/55827bc35e754dec890f4378d308c4f6.png
[21b223d6cab3ce3fbc52d6753978e4ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/888dc6b51eaa459ca5cb064f6d058be8.png