灵魂大拷问：Lock 到底比 synchronized 强在哪？

开篇语

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

  我们都知道一个真相，在 Java 里，synchronized 和 Lock 都是用于实现线程同步的机制。它们的主要目的是确保多个线程在并发执行时不会对共享资源进行冲突的访问，从而保证数据的一致性。虽然 synchronized 和 Lock 都能解决多线程的同步问题，但它们在一些特性和使用场景上存在明显的差异。到底有哪些差异呢？我们接着往下看。

1. synchronized 与 Lock 的基本概念

1.1 synchronized

  synchronized 关键字，它是 Java 中的一种内置同步机制，用于控制线程对共享资源的访问。它可以用于方法或代码块中，确保某个时间内只有一个线程能够执行特定的代码，从而避免并发问题。

public synchronized void method() {
   
    // 只有一个线程可以访问该方法
}

  synchronized 关键字是 Java 内置的同步工具，通常比较简单易用，但它存在一些限制，比如无法实现灵活的锁机制、无法中断等。

1.2 Lock

  而 Lock 是 Java 5 中引入的一个接口，属于 java.util.concurrent 包。它提供了比 synchronized 更加灵活的同步控制。常用的实现类包括 ReentrantLock。

  Lock 它提供了更多的功能，比如可以尝试加锁、可中断的加锁等，允许程序员在更细粒度上控制锁的行为。例如：

Lock lock = new ReentrantLock();

lock.lock(); // 获取锁
try {
   
    // 执行临界区操作
} finally {
   
    lock.unlock(); // 释放锁
}

2. Lock 相比于 synchronized 的优势

  虽然 synchronized 和 Lock 都能达到线程同步的目的，但 Lock 提供了更多的灵活性和控制能力，适用于更复杂的多线程应用场景。以下是 Lock 优于 synchronized 的几个关键点：

2.1 可中断的锁（Interruptible）

  synchronized 在执行时，如果当前线程无法获得锁，它将会一直等待直到获取锁为止。这种方式的一个问题是，如果线程被阻塞在 synchronized 上，它不能响应中断。

  而 Lock 允许通过 lock.lockInterruptibly() 方法来实现可中断的锁。如果线程在获取锁时被中断，它会抛出 InterruptedException 异常，从而可以让线程在被中断时做一些清理工作，提升系统的响应性。

代码示例

如下是示例代码，仅供参考：

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

/**
 * @Author 喵手
 * @date: 2025-04-14
 */
public class InterruptibleLockExample {
   

    private static final Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
   
        // 创建一个线程，模拟一个需要锁的临界区
        Thread workerThread = new Thread(new Worker());

        // 启动 workerThread
        workerThread.start();

        // 主线程睡眠一段时间，确保 workerThread 先尝试获取锁
        Thread.sleep(500);

        // 中断 workerThread，模拟中断场景
        System.out.println("Main thread is interrupting worker thread...");
        workerThread.interrupt();
    }

    static class Worker implements Runnable {
   
        @Override
        public void run() {
   
            try {
   
                System.out.println(Thread.currentThread().getName() + " is trying to acquire the lock...");

                // 尝试获取锁，如果线程被中断，抛出 InterruptedException
                lock.lockInterruptibly();
                try {
   
                    System.out.println(Thread.currentThread().getName() + " acquired the lock.");
                    // 模拟执行临界区代码
                    Thread.sleep(2000);  // 模拟任务执行，时间较长
                } finally {
   
                    // 确保在任务完成后释放锁
                    lock.unlock();
                    System.out.println(Thread.currentThread().getName() + " released the lock.");
                }
            } catch (InterruptedException e) {
   
                // 处理线程中断的逻辑
                System.out.println(Thread.currentThread().getName() + " was interrupted while waiting for the lock.");
                // 可以进行必要的清理工作
            }
        }
    }
}

运行截图展示

如下是正式环境演示截图：

代码解析

  如下是我对上述案例代码的详细剖析，目的就是为了帮助大家更好的理解代码，吃透原理。如上案例代码是一个完整的示例程序，演绎了如何使用 lock.lockInterruptibly() 实现一个可中断的锁机制。在这个例子中，线程会在锁定期间被中断，演示了如何捕获 InterruptedException 并进行相应的处理中断。

1. 创建锁对象：

   private static final Lock lock = new ReentrantLock();
   

  使用 ReentrantLock 类创建一个可中断的锁。与 synchronized 不同，ReentrantLock 提供了更强的灵活性，例如可中断的锁。

2. lock.lockInterruptibly()：

   lock.lockInterruptibly();
   

  这是关键点，lock.lockInterruptibly() 方法会尝试获取锁。如果当前线程在等待锁时被中断，抛出 InterruptedException 异常。相比于 synchronized，它允许线程在获取锁的过程中响应中断。

3. 模拟中断：
     在 main() 方法中，首先启动了一个工作线程 workerThread，它会尝试获取锁并执行一些任务。接着，主线程通过 workerThread.interrupt() 来中断工作线程，这模拟了一个中断的场景。

4. 处理中断：

   catch (InterruptedException e) {
        
       System.out.println(Thread.currentThread().getName() + " was interrupted while waiting for the lock.");
   }
   

  在 Worker 线程中，如果它在等待锁时被中断，会抛出 InterruptedException 异常，捕获后可以进行一些清理工作或其他逻辑处理。

5. 锁的释放：

   lock.unlock();
   

  无论任务是否成功完成，finally 块中都会释放锁，确保不会发生死锁。unlock() 是 lock() 的配对方法，必须在临界区代码执行完毕后调用。

程序执行流程：

1. workerThread 启动并尝试获取锁，但主线程通过 sleep 保证它的获取锁尝试会稍微被延迟。
2. 主线程中断 workerThread，此时 workerThread 在等待锁的时候会被中断，并抛出 InterruptedException。
3. workerThread 捕获异常，并在异常处理中输出 “Thread was interrupted while waiting for the lock”。
4. 线程最终释放锁，确保没有遗留资源。

可能的输出：

Thread-0 is trying to acquire the lock...
Thread-0 acquired the lock.
Main thread is interrupting worker thread...
Thread-0 released the lock.
Thread-0 was interrupted while waiting for the lock.

总结：

• lock.lockInterruptibly() 方法使得线程能够在等待锁时响应中断。
• 通过捕获 InterruptedException，可以在被中断时做出合理的响应，例如进行资源清理、终止操作等。
• finally 块保证了在任务完成后，锁总是会被正确释放，从而避免死锁。

2.2 尝试获取锁（Try Lock）

  synchronized 在获取锁时是阻塞的，也就是说，如果当前线程无法获取锁，它将一直等待，直到可以获取锁。这在某些场景下会导致线程不必要的阻塞。

  而 Lock 提供了 tryLock() 方法，允许线程在获取锁时不阻塞，而是尝试获取锁，如果获取不到就返回 false，或者通过指定超时时间来等待一定的时间再放弃。

代码示例

如下是示例代码，仅供参考：

import java.util.