Java 8 中 ReentrantLock 与 Synchronized 的区别

引言

在Java多线程编程中，确保线程安全是至关重要的。为了实现线程的同步和协作，Java提供了多种同步机制，其中最常见的是使用 synchronized 关键字和 ReentrantLock 类。这两者在实现线程安全的同时，也存在着一些区别。本文将深入讨论这两种同步机制的差异，并结合 Java 8 的特性，解析它们在常见面试题中的应用。

同步机制简介

Synchronized

synchronized 是Java中最早引入的同步机制，通过对方法或代码块加锁来确保多线程环境下的数据一致性。它使用起来简单，不需要手动释放锁，JVM会自动管理。

public synchronized void synchronizedMethod() {
    // 同步代码块
    // ...
}

ReentrantLock

ReentrantLock 是Java 5 中引入的同步机制，相较于 synchronized，它提供了更灵活的锁定方式。通过显式地获取锁和释放锁，程序员可以更精细地控制同步操作。此外，ReentrantLock 还支持可重入性，即一个线程可以多次获取同一个锁。

import java.util.concurrent.locks.ReentrantLock;
public class MyLock {
    private final ReentrantLock lock = new ReentrantLock();
    public void lockedMethod() {
        lock.lock();
        try {
            // 同步代码块
            // ...
        } finally {
            lock.unlock();
        }
    }
}

区别分析

可中断性

一个显著的区别是 ReentrantLock 支持中断等待锁的线程，而 synchronized 不支持。在 ReentrantLock 中，线程可以通过 lockInterruptibly 方法等待锁，如果其他线程中断了当前线程，它可以响应中断而不是一直等待。

ReentrantLock lock = new ReentrantLock();
public void interruptibleMethod() throws InterruptedException {
    lock.lockInterruptibly();
    try {
        // 同步代码块
        // ...
    } finally {
        lock.unlock();
    }
}

公平性

ReentrantLock 可以选择是否公平地获取锁，而 synchronized 是非公平的。在公平模式下，等待时间最长的线程会优先获得锁。在非公平模式下，线程有一定几率在等待队列为空时插队成功。

ReentrantLock fairLock = new ReentrantLock(true); // 公平锁
ReentrantLock unfairLock = new ReentrantLock();     // 非公平锁

条件变量

ReentrantLock 提供了 Condition 接口，可以通过 newCondition 方法创建多个条件变量，用于在不同的情况下等待或唤醒线程。而 synchronized 只能通过 Object 的 wait、notify 和 notifyAll 方法来实现简单的线程协作，缺乏 ReentrantLock 中的灵活性。

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
public void awaitSignal() throws InterruptedException {
    lock.lock();
    try {
        condition.await();
    } finally {
        lock.unlock();
    }
}
public void sendSignal() {
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }
}

性能比较

在 Java 5 之前，synchronized 的性能较差，但在 Java 6 及以后的版本中，对 synchronized 进行了优化，性能已经有了很大的提升。一般来说，在性能上，synchronized 与 ReentrantLock 的差距并不明显。在选择使用时，更应该考虑到代码的可读性和维护性。

Java 8 的新特性

Java 8 引入了函数式编程的特性，同时也对并发编程做出了一些改进。其中一个显著的改变是引入了新的 StampedLock 类，它是 ReentrantLock 的进一步扩展，提供了乐观锁机制，使得在读多写少的场景下性能更优。

import java.util.concurrent.locks.StampedLock;
public class MyStampedLock {
    private final StampedLock lock = new StampedLock();
    public void read() {
        long stamp = lock.tryOptimisticRead();
        // 乐观读操作
        if (!lock.validate(stamp)) {
            // 如果发生了写操作，则使用悲观读锁
            stamp = lock.readLock();
            try {
                // 悲观读操作
            } finally {
                lock.unlockRead(stamp);
            }
        }
    }
    public void write() {
        long stamp = lock.writeLock();
        try {
            // 写操作
        } finally {
            lock.unlockWrite(stamp);
        }
    }
}

面试题解析

什么时候使用 ReentrantLock 而不是 synchronized？

需要支持可中断等待： 如果你的线程需要响应中断而不是一直等待锁，那么 ReentrantLock 是更好的选择。

需要尝试获取锁： ReentrantLock 提供了 tryLock 方法，可以尝试获取锁而不一直等待，可以用于避免死锁。

需要选择公平性： 如果你需要控制线程获取锁的顺序，可以选择 ReentrantLock 的公平锁或非公平锁。

ReentrantLock 的可重入性是什么意思？

可重入性是指同一个线程在持有锁的情况下，能够再次获取这个锁而不发生死锁。ReentrantLock 和 synchronized 都是可重入的，这使得线程可以递归地调用同步方法或同步代码块。

什么是乐观读锁？StampedLock 有什么优势？

乐观读锁是 StampedLock 引入的特性，它允许多个线程同时读取共享资源，而不会阻塞写锁。如果在乐观读锁期间没有写锁被获取，读操作可以立即进行。当然，如果写锁被获取，就需要转为悲观读锁。

StampedLock 的优势在于在读多写少的场景下性能更优，因为它允许多个线程同时读取，而不阻塞彼此。

总结

在Java 8中，ReentrantLock 和 synchronized 依然是同步机制中的主流选择。选择使用哪一种取决于具体的需求和场景。总体而言，synchronized 在简单场景下易用性更高，而 ReentrantLock 则在一些复杂场景下提供了更多的灵活性和控制权。

对于面试而言，了解这两者的区别、使用场景以及新特性，可以展现出对多线程编程深入理解的能力，为应对面试中的技术问题提供有力支持。在实际应用中，结合业务需求和性能要求，选择适当的同步机制是至关重要的。