Java synchronized关键字详解：原理、使用与优化

1. 为什么我们需要synchronized？

作为一名Java开发者，我经常遇到这样的场景：多个线程同时操作同一个银行账户，结果余额莫名其妙地减少了。这就是典型的线程安全问题。synchronized关键字就是为解决这类问题而生的。

在单线程环境下，代码执行是线性的，一切都很美好。但多线程环境下，当多个线程同时访问共享资源时，就会出现数据不一致的问题。比如下面这个简单的计数器：

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

看起来很简单，但在多线程环境下，count++这个操作实际上分为三步：读取count值、增加1、写回count值。如果两个线程同时执行这个操作，可能会出现两个线程都读取到相同的初始值，然后各自加1后写回，导致最终结果只增加了1而不是2。

2. synchronized的三种使用方式

2.1 修饰实例方法

这是最简单的同步方式：

java复制public synchronized void increment() {
    count++;
}

这种方式锁的是当前实例对象（this）。也就是说，同一个对象的同步方法在同一时间只能被一个线程执行。不同实例的方法调用则互不影响。

注意：如果方法中有长时间操作（如IO），会严重影响性能，因为其他线程会被阻塞。

2.2 修饰静态方法

静态方法的同步稍有不同：

java复制public static synchronized void incrementStatic() {
    count++;
}

这里锁的是类的Class对象（Counter.class）。这意味着所有该类的实例调用这个静态方法时都会互斥，因为Class对象在JVM中只有一份。

2.3 同步代码块

最灵活的方式是同步代码块：

java复制public void increment() {
    synchronized(lockObject) {
        count++;
    }
}

这种方式可以精确控制锁的范围和对象。我通常会专门创建一个final对象作为锁：

java复制private final Object lock = new Object();

这样可以避免意外使用其他对象作为锁带来的问题。

3. synchronized的底层原理

3.1 对象头与Monitor

每个Java对象在内存中都有对象头，其中包含Mark Word（存储哈希码、GC年龄和锁信息）和Klass Pointer（指向类元数据）。synchronized就是通过操作对象头来实现同步的。

当线程进入synchronized块时，JVM会尝试获取对象的Monitor（监视器锁）。Monitor是操作系统提供的同步原语，每个对象都关联一个Monitor。

3.2 锁的升级过程

Java 6对synchronized进行了重大优化，引入了锁升级机制：

1. 无锁状态：初始状态，没有任何线程持有锁
2. 偏向锁：当第一个线程获取锁时，进入偏向模式。此时对象头记录线程ID，后续该线程进入同步块只需简单检查，无需原子操作
3. 轻量级锁：当有第二个线程尝试获取锁时，偏向锁升级为轻量级锁。线程通过CAS操作竞争锁
4. 重量级锁：当竞争激烈时（自旋超过一定次数），升级为重量级锁，线程进入阻塞状态

这种设计使得在无竞争或低竞争情况下，同步开销非常小。

4. 锁的优化技巧

4.1 减小锁的粒度

不要锁整个方法，只锁必要的代码块。比如：

java复制// 不好的做法
public synchronized void process() {
    // 大量不相关的代码
    synchronizedPart();
    // 更多不相关的代码
}

// 好的做法
public void process() {
    // 不相关的代码
    synchronized(this) {
        synchronizedPart();
    }
    // 更多不相关的代码
}

4.2 使用专用锁对象

避免使用可能被其他代码使用的对象作为锁：

java复制// 不好的做法
synchronized(collection) {
    // 操作集合
}

// 好的做法
private final Object collectionLock = new Object();

synchronized(collectionLock) {
    // 操作集合
}

4.3 避免锁的嵌套

锁嵌套容易导致死锁。如果必须使用多个锁，确保所有线程以相同的顺序获取锁。

5. 常见问题与解决方案

5.1 死锁问题

死锁的四个必要条件：

1. 互斥条件
2. 占有且等待
3. 不可抢占
4. 循环等待

避免死锁的方法：

• 按固定顺序获取锁
• 使用tryLock设置超时
• 减少锁的持有时间

5.2 性能问题

synchronized在高竞争环境下性能较差。可以考虑：

• 使用并发集合类
• 使用ReadWriteLock
• 考虑使用CAS操作（Atomic类）

5.3 与volatile的区别

volatile只保证可见性和有序性，不保证原子性。synchronized保证三者。对于简单的状态标志，volatile是更好的选择。

6. 实际应用案例

6.1 线程安全的单例模式

java复制public class Singleton {
    private static volatile 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复制public class SimpleCache<K, V> {
    private final Map<K, V> cache = new HashMap<>();
    private final Object lock = new Object();
    
    public void put(K key, V value) {
        synchronized(lock) {
            cache.put(key, value);
        }
    }
    
    public V get(K key) {
        synchronized(lock) {
            return cache.get(key);
        }
    }
}

对于读多写少的场景，可以考虑使用ConcurrentHashMap或ReadWriteLock。

7. 性能测试与对比

我做了个简单的性能测试，比较不同同步方式的吞吐量：

测试环境：4核CPU，8个线程，每个操作循环10000次。

从结果可以看出：

1. 无同步最快，但不安全
2. AtomicInteger在简单计数器场景性能接近无同步
3. synchronized块比方法略快
4. ReentrantLock与synchronized性能相近

8. 最佳实践建议

1. 优先考虑无锁方案：如不可变对象、线程局部变量、原子类等
2. 尽量减小同步范围：只同步必要的代码块
3. 文档化锁策略：明确说明哪些锁保护哪些数据
4. 避免在同步块中调用外部方法：可能导致死锁或性能问题
5. 考虑使用更高层次的并发工具：如并发集合、CountDownLatch等

synchronized是Java并发编程的基础，理解它的原理和使用技巧对于写出正确且高效的多线程代码至关重要。在实际项目中，我通常会先使用synchronized实现基本功能，再根据性能测试结果决定是否需要更复杂的并发控制。