Java 8 中 ReentrantLock 与 Synchronized 的区别

🚀 作者主页：有来技术
🔥 开源项目： youlai-mall 🍃 vue3-element-admin 🍃 youlai-boot
🌺 仓库主页： Gitee 💫 Github 💫 GitCode
💖 欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请纠正！

引言
同步机制简介
- Synchronized
- ReentrantLock
区别分析
- 可中断性
- 公平性
- 条件变量
- 性能比较
Java 8 的新特性
面试题解析
- 什么时候使用 ReentrantLock 而不是 synchronized？
- ReentrantLock 的可重入性是什么意思？
- 什么是乐观读锁？StampedLock 有什么优势？
总结

引言

在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);
        }
    }
}