synchronized和ReentrantLock的区别与适用场景

基本概念

synchronized

synchronized是Java中的关键字，是Java内置的锁机制，也称为监视器锁或内置锁。它可以用来修饰方法或代码块，确保同一时间只有一个线程可以执行被修饰的代码。

ReentrantLock

ReentrantLock是Java并发包java.util.concurrent.locks中的一个类，它提供了比synchronized更广泛的锁定操作。它是一个可重入的互斥锁，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

主要区别

1. 性质与实现方式

2. 功能特性

3. 使用方式

synchronized使用示例

// 修饰方法
public synchronized void method() {
    // 临界区代码
}

// 修饰代码块
public void blockMethod() {
    synchronized (this) {
        // 临界区代码
    }
}

ReentrantLock使用示例

public void lockMethod() {
    ReentrantLock lock = new ReentrantLock();
    lock.lock();  // 获取锁
    try {
        // 临界区代码
    } finally {
        lock.unlock();  // 释放锁
    }
}

4. 锁的获取与释放

5. 异常处理

工作原理对比

synchronized工作原理

synchronized是基于JVM实现的锁机制，其工作原理如下：

1. 当一个线程试图访问同步代码块时，它必须先获得锁；
2. 锁是存储在Java对象头中的Mark Word里的；
3. 如果锁未被其他线程持有，当前线程会获取锁，并将Mark Word中的锁标志位设置为"锁定"；
4. 如果锁已被其他线程持有，当前线程会被阻塞，直到锁被释放；
5. 当线程退出同步代码块时，JVM会自动释放锁。

ReentrantLock工作原理

ReentrantLock是基于AQS（AbstractQueuedSynchronizer）实现的锁机制，其工作原理如下：

1. ReentrantLock内部维护了一个Sync对象，该对象继承自AQS；
2. 当调用lock()方法时，Sync会尝试获取锁；
3. 如果获取成功，将锁的持有者设置为当前线程，并将状态state加1；
4. 如果获取失败，当前线程会被封装成一个Node节点，放入AQS的同步队列中；
5. 当锁被释放时，AQS会从同步队列中取出一个线程唤醒，使其尝试获取锁。

适用场景

synchronized适用场景

1. 简单同步需求：当同步逻辑简单，不需要高级功能时，synchronized是首选。
2. 自动资源管理：希望锁的获取和释放由JVM自动管理，避免忘记释放锁导致死锁。
3. 代码简洁性优先：synchronized语法简洁，代码可读性高。
4. 竞争不激烈：在锁竞争不激烈的情况下，synchronized的性能可能更好，因为JVM会进行优化。
5. 团队技术水平参差不齐：synchronized使用简单，不容易出错，适合团队成员技术水平不一的情况。

ReentrantLock适用场景

1. 需要公平锁：当需要按照线程请求锁的顺序来获取锁时，可以使用ReentrantLock的公平锁。
2. 需要可中断的锁获取：当希望线程在等待锁的过程中可以被中断时，可以使用lockInterruptibly()方法。
3. 需要尝试获取锁：当希望尝试获取锁，但不想一直等待时，可以使用tryLock()方法。
4. 需要超时机制：当希望尝试获取锁，但只愿意等待一定时间时，可以使用tryLock(long, TimeUnit)方法。
5. 需要多个条件变量：当需要在一个锁上关联多个条件时，可以使用ReentrantLock的newCondition()方法创建多个Condition对象。
6. 需要获取锁的等待线程信息：ReentrantLock提供了获取等待线程信息的方法，如getQueueLength()、hasQueuedThreads()等。
7. 高竞争环境下的性能优化：在锁竞争激烈的情况下，ReentrantLock可能提供更好的性能。

性能对比

JDK 1.6之前

在JDK 1.6之前，synchronized的性能远低于ReentrantLock，因为synchronized涉及到用户态到内核态的切换，而ReentrantLock是基于Java API实现的，避免了这种切换。

JDK 1.6及之后

从JDK 1.6开始，对synchronized进行了大量优化，引入了偏向锁、轻量级锁、自旋锁等机制，使得synchronized的性能与ReentrantLock的差距大大缩小。在低竞争的情况下，synchronized的性能甚至可能优于ReentrantLock。

代码示例对比

使用synchronized实现生产者-消费者模型

public class ProducerConsumerWithSync {
    private final List<Integer> buffer = new ArrayList<>();
    private final int capacity;
    
    public ProducerConsumerWithSync(int capacity) {
        this.capacity = capacity;
    }
    
    public void produce(int item) throws InterruptedException {
        synchronized (this) {
            while (buffer.size() == capacity) {
                wait();  // 缓冲区满，等待
            }
            buffer.add(item);
            System.out.println("Produced: " + item);
            notifyAll();  // 通知消费者
        }
    }
    
    public int consume() throws InterruptedException {
        synchronized (this) {
            while (buffer.isEmpty()) {
                wait();  // 缓冲区空，等待
            }
            int item = buffer.remove(0);
            System.out.println("Consumed: " + item);
            notifyAll();  // 通知生产者
            return item;
        }
    }
}

使用ReentrantLock实现生产者-消费者模型

public class ProducerConsumerWithLock {
    private final List<Integer> buffer = new ArrayList<>();
    private final int capacity;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    
    public ProducerConsumerWithLock(int capacity) {
        this.capacity = capacity;
    }
    
    public void produce(int item) throws InterruptedException {
        lock.lock();
        try {
            while (buffer.size() == capacity) {
                notFull.await();  // 缓冲区满，等待
            }
            buffer.add(item);
            System.out.println("Produced: " + item);
            notEmpty.signal();  // 通知消费者
        } finally {
            lock.unlock();
        }
    }
    
    public int consume() throws InterruptedException {
        lock.lock();
        try {
            while (buffer.isEmpty()) {
                notEmpty.await();  // 缓冲区空，等待
            }
            int item = buffer.remove(0);
            System.out.println("Consumed: " + item);
            notFull.signal();  // 通知生产者
            return item;
        } finally {
            lock.unlock();
        }
    }
}

总结

synchronized和ReentrantLock都是Java中用于实现线程同步的机制，但它们在功能、性能和使用方式上有明显的区别。

• synchronized是Java关键字，使用简单，自动管理锁的获取和释放，适合简单的同步场景。
• ReentrantLock是Java类，提供了更丰富的功能，如公平锁、可中断锁、超时锁等，适合需要高级功能的复杂同步场景。

在选择使用哪种锁机制时，应根据具体需求、性能要求和团队技术水平来决定。在大多数情况下，如果不需要ReentrantLock提供的高级功能，推荐使用synchronized，因为它更简单、更安全，并且在现代JVM中性能也很好。

参考资料

1. Java并发编程实战 (Java Concurrency in Practice)
2. Oracle Java文档: ReentrantLock
3. Oracle Java文档: synchronized Methods
4. 深入理解Java虚拟机：JVM高级特性与最佳实践
5. Java并发编程的艺术