synchronized与ReentrantLock对比分析

基本概念

synchronized

• Java内置关键字，提供了一种内置的锁机制
• 也称为监视器锁或内置锁
• 可以用来修饰方法或代码块
• 在Java 1.6之后进行了大量优化，包括偏向锁、轻量级锁、适应性自旋等

ReentrantLock

• Java 5引入的java.util.concurrent.locks包中的类
• 是一种可重入的互斥锁
• 提供了比synchronized更广泛的锁定操作
• 需要手动获取和释放锁

功能特性对比

性能对比

synchronized性能特点

• Java 1.6之前：性能较差，每次获取和释放锁都会涉及用户态到内核态的切换
• Java 1.6及以后：引入了多种优化机制，性能大幅提升
  • 偏向锁：当一个线程获取锁后，锁会偏向这个线程，之后该线程再次获取锁时无需进行同步操作
  • 轻量级锁：在没有竞争的情况下，使用CAS操作来获取锁，避免使用操作系统互斥量
  • 适应性自旋：根据历史锁获取情况，动态调整自旋次数

ReentrantLock性能特点

• 低竞争情况：性能与synchronized相当，但略逊于优化后的synchronized
• 高竞争情况：通常表现优于synchronized，特别是使用tryLock()避免死锁时
• 灵活性优势：可以更精细地控制锁的行为，减少不必要的线程阻塞

性能总结

• 在低竞争场景下，synchronized可能具有更好的性能，因为它是JVM内置的，可以进行更多的优化
• 在高竞争场景下，ReentrantLock可能表现更好，特别是当使用tryLock()避免死锁时
• 随着JVM版本的更新，synchronized的性能持续提升，与ReentrantLock的差距逐渐缩小

使用场景

synchronized适合的场景

1. 锁竞争不激烈的情况
2. 需要简单、简洁的代码
3. 不需要锁的高级功能（如公平性、定时锁等）
4. 不需要手动控制锁的获取和释放
5. 团队对并发编程经验较少，需要降低出错风险

ReentrantLock适合的场景

1. 需要可中断的锁获取操作
2. 需要尝试获取锁，并在获取失败时执行其他操作
3. 需要公平锁，避免线程饥饿
4. 需要多个条件变量进行线程间通信
5. 需要获取锁的状态信息
6. 需要更灵活的锁粒度控制
7. 需要实现复杂的同步逻辑，如链式锁定

代码示例

synchronized示例

public class SynchronizedExample {
    private int count = 0;
    
    // 同步方法
    public synchronized void increment() {
        count++;
    }
    
    // 同步代码块
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
    
    public int getCount() {
        return count;
    }
}

ReentrantLock示例

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

public class ReentrantLockExample {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    
    public void increment() {
        lock.lock();  // 获取锁
        try {
            count++;
        } finally {
            lock.unlock();  // 释放锁
        }
    }
    
    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }
    
    // 尝试获取锁
    public boolean tryIncrement() {
        if (lock.tryLock()) {  // 尝试获取锁，立即返回
            try {
                count++;
                return true;
            } finally {
                lock.unlock();
            }
        } else {
            return false;  // 获取锁失败
        }
    }
    
    // 可中断锁获取
    public void interruptibleIncrement() throws InterruptedException {
        lock.lockInterruptibly();  // 可中断地获取锁
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    
    // 使用条件变量
    public void awaitWhenZero() throws InterruptedException {
        lock.lock();
        try {
            while (count != 0) {
                condition.await();  // 等待条件满足
            }
        } finally {
            lock.unlock();
        }
    }
    
    public void signalWhenChanged() {
        lock.lock();
        try {
            condition.signalAll();  // 通知所有等待线程
        } finally {
            lock.unlock();
        }
    }
}

总结

synchronized和ReentrantLock都是Java中重要的锁机制，它们各有优缺点：

• synchronized是Java内置的锁机制，使用简单，自动管理锁的获取和释放，在Java 1.6之后性能大幅提升，适合大多数简单同步场景。

• ReentrantLock提供了更丰富的功能，如可中断锁、尝试获取锁、公平锁、多个条件变量等，使用更灵活，但需要手动管理锁的获取和释放，适合需要高级功能的复杂同步场景。

在实际开发中，应根据具体需求选择合适的锁机制。如果不需要ReentrantLock提供的高级功能，优先考虑使用synchronized，因为它更简单、更安全，且性能已经足够好。只有在确实需要ReentrantLock提供的高级功能时，才选择使用它。