在Java并发编程中，synchronized是最基础也最重要的同步工具之一。很多开发者只知道它能保证线程安全，却对其底层实现一知半解。本文将深入JVM底层，拆解synchronized的实现原理，详解从偏向锁、轻量级锁到重量级锁的完整升级流程，并介绍JVM为优化synchronized性能所做的努力。

synchronized可以保证在同一时刻，只有一个线程能执行特定的代码块或方法。它主要有三种使用方式：同步代码块、同步实例方法和同步静态方法。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * synchronized基本用法示例
 *
 * @author ken
 */
@Slf4j
public class SynchronizedUsageDemo {

    private final Object lock = new Object();
    private static int staticCount = 0;
    private int instanceCount = 0;

    /**
     * 同步代码块：对象锁
     */
    public void syncBlock() {
        synchronized (lock) {
            instanceCount++;
            log.info("同步代码块执行，instanceCount: {}", instanceCount);
        }
    }

    /**
     * 同步实例方法：锁当前对象this
     */
    public synchronized void syncInstanceMethod() {
        instanceCount++;
        log.info("同步实例方法执行，instanceCount: {}", instanceCount);
    }

    /**
     * 同步静态方法：锁当前类的Class对象
     */
    public static synchronized void syncStaticMethod() {
        staticCount++;
        log.info("同步静态方法执行，staticCount: {}", staticCount);
    }

    public static void main(String[] args) {
        SynchronizedUsageDemo demo = new SynchronizedUsageDemo();
        new Thread(demo::syncBlock).start();
        new Thread(demo::syncInstanceMethod).start();
        new Thread(SynchronizedUsageDemo::syncStaticMethod).start();
        new Thread(SynchronizedUsageDemo::syncStaticMethod).start();
    }
}

要理解synchronized的底层实现，首先得了解Java对象在内存中的布局。Java对象由三部分组成：对象头、实例数据和对齐填充。其中对象头是实现锁的关键，它包含两部分信息：Mark Word和Klass Pointer。 Mark Word用于存储对象自身的运行时数据，如哈希码、GC分代年龄、锁状态标志等。在64位JVM中，Mark Word的长度是64bit，其结构会根据锁状态的不同而变化。

我们可以通过JOL（Java Object Layout）工具来查看对象头的实际布局。

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

package com.jam.demo;

import org.openjdk.jol.info.ClassLayout;

/**
 * 查看对象头布局示例
 *
 * @author ken
 */
public class ObjectHeaderDemo {

    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}

JDK 1.6之后，synchronized引入了锁升级机制，以减少获取锁和释放锁带来的性能消耗。锁会从无锁开始，随着竞争的加剧，逐渐升级为偏向锁、轻量级锁，最终升级为重量级锁。

当只有一个线程访问同步块时，JVM会将锁偏向于该线程，后续该线程再次访问时，无需进行任何同步操作，直接进入同步块。 偏向锁的获取流程：

当偏向锁被撤销或有多个线程交替使用锁时，锁会升级为轻量级锁。轻量级锁使用CAS操作来尝试获取锁，避免了重量级锁的线程阻塞和唤醒开销。 轻量级锁的加锁流程：

当锁竞争激烈，轻量级锁的CAS操作和自旋都无法获取锁时，锁会升级为重量级锁。重量级锁基于ObjectMonitor实现，此时线程会被阻塞，等待锁释放后被唤醒。 ObjectMonitor是JVM内部的一个对象，包含以下关键字段：

JVM为了提高synchronized的性能，引入了多种锁优化机制，包括自适应自旋、锁消除、锁粗化和逃逸分析。

轻量级锁加锁失败时，线程会进行自旋等待，而不是直接阻塞。自适应自旋意味着自旋的时间不是固定的，而是根据前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。如果前一次自旋成功获取了锁，JVM会认为这次自旋也很可能成功，从而延长自旋时间；如果前一次自旋失败，JVM会缩短自旋时间，甚至直接跳过自旋。

锁消除是指JIT编译器在运行时，通过逃逸分析发现某个对象不会被其他线程访问，那么该对象的锁就可以被消除。因为不会有线程竞争，所以加锁和解锁操作是多余的。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 锁消除示例
 *
 * @author ken
 */
@Slf4j
public class LockEliminationDemo {

    /**
     * 方法中的StringBuffer是局部变量，不会逃逸，JIT会消除锁
     */
    public String concat(String a, String b, String c) {
        StringBuffer sb = new StringBuffer();
        sb.append(a);
        sb.append(b);
        sb.append(c);
        return sb.toString();
    }

    public static void main(String[] args) {
        LockEliminationDemo demo = new LockEliminationDemo();
        for (int i = 0; i < 100000; i++) {
            demo.concat("a", "b", "c");
        }
        log.info("执行完成");
    }
}

锁粗化是指将连续的加锁和解锁操作合并成一个更大的锁范围，减少加锁和解锁的次数。如果一个线程连续对同一个对象进行多次加锁和解锁，JIT会将这些操作合并，只进行一次加锁和解锁。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 锁粗化示例
 *
 * @author ken
 */
@Slf4j
public class LockCoarseningDemo {

    private final Object lock = new Object();
    private int count = 0;

    /**
     * 连续的加锁解锁，JIT会粗化锁范围
     */
    public void increment() {
        synchronized (lock) {
            count++;
        }
        synchronized (lock) {
            count++;
        }
        synchronized (lock) {
            count++;
        }
    }

    public static void main(String[] args) {
        LockCoarseningDemo demo = new LockCoarseningDemo();
        for (int i = 0; i < 100000; i++) {
            demo.increment();
        }
        log.info("count: {}", demo.count);
    }
}

逃逸分析是JVM的一种分析技术，用于判断对象的作用域是否会逃逸出方法或线程。如果对象不会逃逸，JVM可以进行以下优化：

在使用synchronized时，如果不注意加锁顺序，可能会导致死锁。死锁是指两个或多个线程互相等待对方释放锁，导致所有线程都无法继续执行。

package com.jam.demo;

import lombok.extern.slf4j.Slf4j;

/**
 * 死锁示例
 *
 * @author ken
 */
@Slf4j
public class DeadlockDemo {

    private static final Object LOCK_A = new Object();
    private static final Object LOCK_B = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (LOCK_A) {
                log.info("线程1获取到LOCK_A");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    log.error("线程中断", e);
                }
                synchronized (LOCK_B) {
                    log.info("线程1获取到LOCK_B");
                }
            }
        }, "线程1").start();

        new Thread(() -> {
            synchronized (LOCK_B) {
                log.info("线程2获取到LOCK_B");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    log.error("线程中断", e);
                }
                synchronized (LOCK_A) {
                    log.info("线程2获取到LOCK_A");
                }
            }
        }, "线程2").start();
    }
}

运行程序后，我们可以通过jstack工具排查死锁：

synchronized的底层实现涉及对象头、Mark Word、锁升级和各种优化机制。理解这些原理，不仅能帮助我们写出更高效的并发代码，还能在遇到并发问题时快速定位和解决。

深入拆解 synchronized：从偏向锁到重量级锁的升级之旅与优化秘籍

本文深入剖析Java中synchronized的底层实现：详解偏向锁、轻量级锁到重量级锁的升级机制，结合对象头Mark Word结构、JVM锁优化（自旋、消除、粗化、逃逸分析），并附死锁排查实战，助你真正掌握并发同步原理。

人工智能

深入解析Java synchronized底层原理，详解偏向锁、轻量级锁到重量级锁的升级流程。揭秘JVM锁优化机制，包括自适应自旋、锁消除、锁粗化和逃逸分析，助你掌握高效并发编程技巧。

编译器

Java

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

深入拆解 synchronized：从偏向锁到重量级锁的升级之旅与优化秘籍

深入拆解 synchronized：从偏向锁到重量级锁的升级之旅与优化秘籍

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐