Java synchronized关键字原理与并发编程实践

1. Java synchronized 关键字深度解析

在 Java 并发编程中，synchronized 是最基础也是最常用的线程同步机制。作为 Java 内置的关键字，它提供了一种简单有效的方式来控制多线程对共享资源的访问。本文将全面剖析 synchronized 的工作原理、使用方式以及底层实现机制。

1.1 synchronized 的核心作用

synchronized 主要解决多线程环境下的三个核心问题：

1. 互斥性：确保同一时刻只有一个线程可以执行被 synchronized 修饰的代码块或方法
2. 可见性：保证一个线程对共享变量的修改能够立即对其他线程可见
3. 有序性：防止编译器和处理器对指令进行重排序，确保代码执行顺序符合预期

在实际开发中，我们经常遇到需要保证线程安全的场景。比如电商系统中的库存扣减、银行系统的账户余额操作等，都需要使用 synchronized 或其他同步机制来保证数据一致性。

2. synchronized 的三种使用方式

2.1 同步实例方法

同步实例方法是最简单的使用方式，通过在方法声明中添加 synchronized 关键字实现：

java复制public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

这种方式的锁对象是当前实例（this），因此：

• 不同实例之间的同步互不影响
• 适用于保护实例变量的线程安全
• 等价于在方法体内使用 synchronized(this) 代码块

注意：同步方法会降低并发性能，因为同一实例的所有同步方法都会互斥。如果方法之间没有共享变量，应考虑使用不同的锁对象。

2.2 同步静态方法

静态方法的同步使用类对象作为锁：

java复制public class StaticCounter {
    private static int count = 0;
    
    public static synchronized void increment() {
        count++;
    }
    
    // 错误的同步方式
    public void wrongIncrement() {
        synchronized(this) {  // 锁对象错误，无法保护静态变量
            count++;
        }
    }
}

关键特点：

• 锁对象是类的 Class 对象（如 StaticCounter.class）
• 所有实例共享同一把锁
• 必须使用静态同步方法或显式同步类对象来保护静态变量

2.3 同步代码块

同步代码块提供了更灵活的同步控制：

java复制public class FineGrainedLock {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    private int value1 = 0;
    private int value2 = 0;
    
    public void updateValue1() {
        synchronized(lock1) {
            value1++;
        }
    }
    
    public void updateValue2() {
        synchronized(lock2) {
            value2--;
        }
    }
}

优势：

• 可以指定任意对象作为锁
• 实现更细粒度的锁控制
• 减少锁竞争，提高并发性能
• 推荐使用专门的私有锁对象而非 this 或类对象

3. synchronized 的底层实现原理

3.1 对象内存布局与锁标识

在 HotSpot 虚拟机中，每个对象都有一个对象头，其中包含用于同步的 Mark Word：

code复制|-------------------------------------------------------|
|                  Mark Word (64 bits)                  |
|-------------------------------------------------------|
| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |
|-------------------------------------------------------|

锁状态通过最后 3 位表示：

• 001：无锁/偏向锁
• 000：轻量级锁
• 010：重量级锁
• 011：GC 标记

3.2 锁升级过程

JVM 为了优化同步性能，设计了锁升级机制：

1. 偏向锁：适用于只有一个线程访问同步块的场景

   • 通过 CAS 设置线程 ID
   • 加锁解锁无额外消耗
   • JDK 15 后默认禁用

2. 轻量级锁：适用于线程交替执行的场景

   • 通过 CAS 将对象头替换为指向栈中锁记录的指针
   • 自旋获取锁，避免线程阻塞

3. 重量级锁：适用于多线程激烈竞争的场景

   • 使用操作系统的互斥量实现
   • 线程阻塞，进入等待队列
   • 涉及用户态到内核态的切换，开销较大

3.3 Monitor 机制

每个 Java 对象都与一个 Monitor 关联，Monitor 的主要组成部分：

• _owner：持有锁的线程
• _cxq：竞争锁的线程队列
• _EntryList：等待锁的线程队列
• _WaitSet：调用 wait() 的线程队列

当线程进入 synchronized 块时：

1. 尝试获取对象的 Monitor
2. 成功则成为 _owner，失败则进入 _cxq 队列
3. 执行完成后释放 Monitor，唤醒等待线程

4. synchronized 的优化技巧

4.1 减小锁粒度

将大锁拆分为多个小锁，减少锁竞争：

java复制// 不推荐 - 粗粒度锁
public class CoarseLock {
    private final Object lock = new Object();
    private int a, b, c;
    
    public void updateAll() {
        synchronized(lock) {
            a++;
            b++;
            c++;
        }
    }
}

// 推荐 - 细粒度锁
public class FineLock {
    private final Object lockA = new Object();
    private final Object lockB = new Object();
    private final Object lockC = new Object();
    private int a, b, c;
    
    public void updateA() {
        synchronized(lockA) { a++; }
    }
    
    public void updateB() {
        synchronized(lockB) { b++; }
    }
}

4.2 锁消除

JVM 会对不可能存在竞争的锁进行消除：

java复制public String concat(String s1, String s2) {
    // StringBuffer 内部方法是同步的
    // 但这里的 sb 是局部变量，不会被其他线程访问
    // JVM 会进行锁消除优化
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
}

4.3 锁粗化

将连续的多个加锁解锁操作合并为一个：

java复制// 优化前
public void before() {
    for (int i = 0; i < 100; i++) {
        synchronized(lock) {
            // 少量操作
        }
    }
}

// 优化后
public void after() {
    synchronized(lock) {
        for (int i = 0; i < 100; i++) {
            // 合并操作
        }
    }
}

5. synchronized 的局限性

尽管 synchronized 使用简单，但也存在一些限制：

1. 不可中断：等待锁的线程无法被中断，会一直阻塞
2. 非公平锁：新请求的线程可能比等待久的线程先获取锁
3. 单一条件：每个锁只有一个等待队列，无法实现多条件通知
4. 性能问题：重量级锁状态下性能较差

对于需要更复杂同步控制的场景，可以考虑使用 java.util.concurrent 包中的 Lock 接口及其实现类。

6. 实际应用中的经验分享

6.1 双重检查锁定模式

单例模式的经典实现：

java复制public class Singleton {
    private volatile static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

关键点：

• volatile 防止指令重排序
• 双重检查减少同步开销
• 私有构造器防止外部实例化

6.2 线程安全计数器对比

不同实现方式的性能比较：

java复制// 1. synchronized 方式
private int count1 = 0;
public synchronized void inc1() { count1++; }

// 2. AtomicInteger 方式
private AtomicInteger count2 = new AtomicInteger(0);
public void inc2() { count2.incrementAndGet(); }

// 3. LongAdder 方式 (高并发最优)
private LongAdder count3 = new LongAdder();
public void inc3() { count3.increment(); }

性能测试结果（100个线程，每个递增10000次）：

• synchronized：约 500ms
• AtomicInteger：约 200ms
• LongAdder：约 50ms

6.3 避免死锁的实践

死锁产生的四个必要条件：

1. 互斥条件
2. 请求与保持
3. 不剥夺条件
4. 循环等待

避免死锁的策略：

• 按固定顺序获取锁
• 使用 tryLock 设置超时
• 减少同步代码块的大小
• 使用更高级的并发工具

java复制// 按固定顺序获取锁
public void transfer(Account from, Account to, int amount) {
    Account first = from.id < to.id ? from : to;
    Account second = from.id < to.id ? to : from;
    
    synchronized(first) {
        synchronized(second) {
            // 转账操作
        }
    }
}

7. 常见问题排查

7.1 性能问题排查

当发现系统性能下降时，可以检查：

1. 是否过度使用 synchronized
2. 锁竞争是否激烈（使用 JConsole 或 VisualVM 监控）
3. 是否可以使用更细粒度的锁
4. 是否可以考虑使用并发容器替代同步

7.2 死锁排查

使用 jstack 工具检测死锁：

bash复制jstack <pid>

输出示例：

code复制Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x00007f88a8003fc8 (object 0x000000076abcec58, a java.lang.Object),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x00007f88a8001428 (object 0x000000076abcec68, a java.lang.Object),
  which is held by "Thread-1"

7.3 锁升级监控

使用 JOL 工具观察锁状态变化：

java复制Object obj = new Object();
System.out.println(ClassLayout.parseInstance(obj).toPrintable());

synchronized(obj) {
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
}

输出示例：

code复制// 无锁状态
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION
      0     4        (object header)  01 00 00 00 (00000001 00000000 00000000 00000000)

// 轻量级锁状态
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION
      0     4        (object header)  f8 f1 1f 03 (11111000 11110001 00011111 00000011)

8. 最佳实践总结

1. 优先使用同步代码块：相比同步方法，能提供更细粒度的控制
2. 使用私有锁对象：避免外部干扰，提高封装性
3. 保持同步块简短：减少锁持有时间，降低死锁风险
4. 注意锁的可见性：确保所有线程看到的是同一个锁对象
5. 考虑替代方案：对于高并发场景，评估使用 Lock、StampedLock 或并发容器的可能性
6. 避免嵌套锁：容易导致死锁，如需使用必须确保顺序一致
7. 文档化锁策略：在代码中明确说明使用了哪些锁及其保护的对象

synchronized 作为 Java 并发编程的基石，理解其工作原理和最佳实践对于编写正确、高效的并发程序至关重要。随着 Java 版本的演进，虽然出现了更多高级的并发工具，但 synchronized 因其简单可靠的特点，仍然是许多场景下的首选方案。