【JAVA面试题】探索多线程同步：ReentrantLock与synchronized的对比解析

程序员如何搞副业？

强烈推荐

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站:人工智能

---

引言：

在多线程编程中，确保共享资源的安全访问是至关重要的。

为了避免数据竞争和不确定的结果，我们需要使用适当的同步机制来保护共享资源。

Java 中提供了两种主要的线程同步机制：ReentrantLock 和 synchronized。

虽然它们都可以实现线程同步，但在具体的应用中，我们需要根据需求和场景来选择合适的方法。

本文将介绍 ReentrantLock 和 synchronized 的异同点，并通过示例演示它们的应用场景和用法。

---

ReentrantLock介绍

ReentrantLock 是 Java 中用于实现锁的一个类，它提供了与 synchronized 关键字类似的功能，但更加灵活和强大。与 synchronized 相比，ReentrantLock 提供了更多的操作和控制选项。

1. 可重入性（Reentrancy）：

   与 synchronized 类似，ReentrantLock 支持线程的可重入性，即同一个线程可以多次获取同一个锁而不会造成死锁。

2. 公平性（Fairness）：

   ReentrantLock 可以选择是否公平地进行锁的获取。公平锁是指锁的获取按照线程请求的顺序来分配，而非公平锁则不保证这种顺序。公平锁可以避免某些线程长时间被阻塞的情况，但会带来一些性能损耗。

3. 条件变量（Condition）：

   ReentrantLock 提供了 Condition 接口，可以用来在锁上等待或者唤醒特定的条件。这使得在某些情况下，我们可以更加灵活地控制线程的等待和唤醒。

4. 可中断性（Interruption）：

   与 synchronized 不同，ReentrantLock 提供了可中断的获取锁的方法。即在等待锁的过程中，线程可以响应中断信号而提前退出等待。

5. 超时获取（Timeout）：

   ReentrantLock 提供了尝试获取锁的方法，允许线程在一定的时间内尝试获取锁，如果超过指定的时间仍未获取到锁，则返回失败。

使用 ReentrantLock 需要手动进行锁的获取和释放，相对于 synchronized 更加灵活，但也需要更加小心地处理锁的获取和释放，以避免出现死锁等问题。

---

synchronized 的介绍

synchronized 是 Java 中用于实现线程同步的关键字，可以用来确保多个线程不会同时访问共享资源，从而避免数据竞争和不确定的结果。

1. 互斥性（Mutual Exclusion）：

   synchronized 关键字可以应用于方法或代码块，确保同一时刻只有一个线程可以执行被 synchronized 修饰的代码，其他线程必须等待当前线程执行完毕才能执行该代码块或方法。

2. 可见性（Visibility）：

   通过synchronized关键字，线程在释放锁时会将修改的变量值刷新到主内存，从而保证了在不同线程间的可见性，即一个线程对共享变量的修改对其他线程是可见的。

3. 原子性（Atomicity）：

   synchronized 块中的代码被视为一个不可分割的整体，称为原子操作。这确保了在同一时刻只有一个线程可以执行 synchronized 块中的代码，从而避免了因多线程并发访问而导致的数据不一致问题。

4. 隐式锁和释放：

   与 ReentrantLock 不同，synchronized 使用起来更加简洁，不需要显式地获取和释放锁，锁的获取和释放由 JVM 隐式地管理。

虽然 synchronized 简单易用，但也有一些限制，例如无法设置超时、不支持非块结构的条件等待。在性能方面，synchronized 相对于 ReentrantLock 可能会有一些性能开销，尤其是在高并发场景下。

---

ReentrantLock 和synchronized 的异同点

ReentrantLock 和 synchronized 都可以用于实现线程同步，但在实现细节、功能和使用方式上有一些异同点：

相同点：

1. 实现线程同步：

   ReentrantLock 和 synchronized 都可以确保多个线程之间对共享资源的访问是线程安全的，避免了数据竞争和不确定的结果。

2. 可重入性：

   两者都支持线程的可重入性，即同一个线程可以多次获取同一个锁而不会造成死锁。

3. 内置的可见性和原子性：

   无论是 ReentrantLock 还是 synchronized，在释放锁时都会将修改的变量值刷新到主内存，从而保证了在不同线程间的可见性，并且锁的获取和释放都是原子操作。

不同点：

1. 灵活性和控制性：

   • ReentrantLock 相比 synchronized 更加灵活，提供了更多的操作和控制选项，例如可中断性、公平性、超时获取等，以及条件变量的支持。
   • synchronized 使用起来更加简洁，不需要显式地获取和释放锁，锁的管理由 JVM 隐式地完成。

2. 可中断性：

   • ReentrantLock 支持可中断的锁获取操作，即在等待锁的过程中可以响应中断信号而提前退出等待。
   • synchronized 不支持可中断性，一旦线程进入等待状态，只能等待锁的释放。

3. 公平性：

   • ReentrantLock 可以选择是否公平地进行锁的获取，即锁的获取按照线程请求的顺序来分配。
   • synchronized 不提供公平性选项，它总是非公平的。

4. 性能开销：

   • 在性能方面，一般情况下 synchronized 的性能优于 ReentrantLock，因为 synchronized 的实现经过 JVM 的优化，而 ReentrantLock 的实现较为复杂，可能会有一些额外的性能开销。但在高并发场景下，ReentrantLock 的性能可能会更好，因为它提供了更多的控制选项，可以更好地适应特定的应用场景。

综上所述，选择使用 ReentrantLock 还是 synchronized 取决于具体的需求和应用场景，通常情况下建议优先考虑使用 synchronized，除非需要 ReentrantLock 提供的额外功能和灵活性。

---

ReentrantLock 和synchronized 的应用场景

ReentrantLock 和 synchronized 都可以用于实现线程同步，但它们的应用场景有一些差异：

ReentrantLock 的场景：

1. 需要更灵活的锁控制：

   如果需要更多的锁控制选项，例如可中断性、公平性、超时获取等，ReentrantLock 是一个更好的选择。例如，在某些情况下，需要能够在等待锁的过程中响应中断信号而提前退出等待，这时候就可以使用 ReentrantLock 的可中断锁。

2. 需要实现读写分离锁：

   ReentrantReadWriteLock 是 ReentrantLock 的一个扩展，提供了读写分离锁的功能，适用于读多写少的场景。

3. 需要手动释放锁：

   ReentrantLock 需要手动进行锁的获取和释放，这种手动释放锁的方式可能在某些场景下更加灵活，但也需要更小心地处理锁的获取和释放，以避免出现死锁等问题。

适合使用 synchronized 的场景：

1. 简单的同步需求：

   对于简单的同步需求，例如对单个方法或代码块进行同步，没有额外的锁控制需求，使用 synchronized 更加简洁和方便。

2. 性能要求不是关键因素：

   在性能要求不是关键因素的情况下，使用 synchronized 更加方便，因为它不需要额外的锁管理开销，而且 JVM 对其进行了优化。

3. 易于理解和维护：

   synchronized 使用起来更加简单，不需要手动释放锁，对于代码的可读性和维护性更加友好。

选择使用 ReentrantLock 还是 synchronized 取决于具体的需求和应用场景。

通常情况下，如果没有特殊的锁控制需求，并且性能要求不是关键因素，建议优先考虑使用 synchronized，因为它更简单、更方便。

而在需要更灵活的锁控制、或者性能要求较高的场景下，可以考虑使用 ReentrantLock。

---

ReentrantLock 和synchronized 的应用实例

使用 ReentrantLock 实现线程同步：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++; // 临界区代码
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();

        // 创建多个线程并启动
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    example.increment(); // 调用 increment 方法
                }
            }).start();
        }

        // 等待所有线程执行完毕
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出最终的 count 值
        System.out.println("Final count: " + example.getCount());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

使用 synchronized 实现线程同步：

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() { // 使用 synchronized 关键字修饰方法
        count++; // 临界区代码
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();

        // 创建多个线程并启动
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    example.increment(); // 调用 increment 方法
                }
            }).start();
        }

        // 等待所有线程执行完毕
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出最终的 count 值
        System.out.println("Final count: " + example.getCount());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

---

总结：

在多线程编程中，选择合适的线程同步机制对于程序的性能和正确性至关重要。

ReentrantLock 和 synchronized 都是有效的线程同步机制，每种机制都有其优势和适用场景。

在实际开发中，我们应该根据具体的需求和场景来选择合适的机制，并且在编写多线程代码时，始终注意避免死锁和性能瓶颈等问题，以确保程序的正确性和高效性。

---

强烈推荐

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站:人工智能

专栏集锦

大佬们可以收藏以备不时之需：

Spring Boot 专栏：http://t.csdnimg.cn/peKde

ChatGPT 专栏：http://t.csdnimg.cn/cU0na

Java 专栏：http://t.csdnimg.cn/YUz5e

Go 专栏：http://t.csdnimg.cn/Jfryo

Netty 专栏：http://t.csdnimg.cn/0Mp1H

Redis 专栏：http://t.csdnimg.cn/JuTue

Mysql 专栏：http://t.csdnimg.cn/p1zU9

架构之路 专栏：http://t.csdnimg.cn/bXAPS

---

写在最后

感谢您的支持和鼓励！