【Java 基础篇】Java线程同步：Lock接口详解

news2025/2/27 12:13:31

在这里插入图片描述

在多线程编程中，线程同步是一个重要的话题。为了确保多个线程可以正确地协同工作，Java提供了多种线程同步机制。其中，Lock接口是一种强大而灵活的线程同步机制，它提供了比传统的synchronized关键字更多的控制和功能。本文将详细介绍Lock接口的使用，旨在帮助基础小白更好地理解线程同步问题。

什么是Lock接口？

Lock接口是Java提供的一种线程同步机制，它允许线程以排他性的方式访问共享资源。与synchronized关键字不同，Lock接口提供了更灵活的锁定和解锁操作，以及更多的控制选项。

Lock接口的主要实现类是ReentrantLock，它是一种可重入锁，意味着同一个线程可以多次获取同一把锁，而不会发生死锁。除了ReentrantLock，Java还提供了其他类型的锁，如ReentrantReadWriteLock等。

使用Lock接口进行线程同步

基本用法

使用Lock接口进行线程同步的基本用法如下：

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

public class LockExample {
    private Lock lock = new ReentrantLock();

    public void performTask() {
        lock.lock(); // 获取锁
        try {
            // 同步代码块
            // ...
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

在上面的代码中，我们首先创建了一个ReentrantLock的实例，然后在performTask方法中使用lock()方法获取锁，使用unlock()方法释放锁。与synchronized关键字不同，Lock接口的锁定和解锁操作是显式的，这使得代码的逻辑更加清晰。

可重入性

Lock接口支持可重入性，这意味着同一个线程可以多次获取同一把锁而不会发生死锁。这与synchronized关键字的行为相似。

下面是一个示例，演示了可重入性的特性：

public class ReentrantLockExample {
    private Lock lock = new ReentrantLock();

    public void outerMethod() {
        lock.lock(); // 第一次获取锁
        try {
            innerMethod(); // 调用内部方法
        } finally {
            lock.unlock(); // 第一次释放锁
        }
    }

    public void innerMethod() {
        lock.lock(); // 第二次获取锁
        try {
            // 同步代码块
            // ...
        } finally {
            lock.unlock(); // 第二次释放锁
        }
    }
}

在上述示例中，outerMethod和innerMethod都使用了相同的ReentrantLock实例，且innerMethod在outerMethod中被调用，但由于可重入性，它们都能正常工作。

公平锁和非公平锁

ReentrantLock可以是公平锁（Fair Lock）或非公平锁（Nonfair Lock）。默认情况下，ReentrantLock是非公平锁，即锁的获取是无序的，不保证等待时间最长的线程最先获取锁。而公平锁会按照线程的等待时间来获取锁，等待时间最长的线程会最先获取锁。

要创建一个公平锁，可以在创建ReentrantLock实例时传入true作为参数，如下所示：

ReentrantLock fairLock = new ReentrantLock(true);

需要注意的是，公平锁会增加一些额外的性能开销，因此只有在确实需要时才使用它。

高级特性

除了基本用法外，Lock接口还提供了一些高级特性，如条件变量、超时获取锁等。

条件变量

Lock接口还提供了条件变量（Condition）的支持，用于实现更复杂的线程等待和通知机制。条件变量通常与await()和signal()方法一起使用。

下面是一个简单的示例，演示了如何使用条件变量等待某个条件的发生：

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

public class ConditionExample {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void waitForCondition() throws InterruptedException {
        lock.lock();
        try {
            while (!conditionIsMet()) {
                condition.await(); // 等待条件变量
            }
            // 条件满足，继续执行
        } finally {
            lock.unlock();
        }
    }

    public void signalCondition() {
        lock.lock();
        try {
            // 修改条件
            modifyCondition();
            condition.signal(); // 通知等待线程条件已发生变化
        } finally {
            lock.unlock();
        }
    }

    private boolean conditionIsMet() {
        // 检查条件是否满足
        // ...
        return true;
    }

    private void modifyCondition() {
        // 修改条件
        // ...
    }
}

在上述示例中，waitForCondition方法等待条件变量的发生，如果条件不满足，则调用await()方法使线程进入等待状态。signalCondition方法负责修改条件并通知等待线程条件已发生变化。

超时获取锁

Lock接口还允许线程在尝试获取锁时设置超时时间，以避免无限等待锁的释放。这可以通过tryLock(long timeout, TimeUnit unit)方法来实现。

下面是一个示例，演示了如何使用超时获取锁的功能：

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

public class TimeoutLockExample {
    private Lock lock = new ReentrantLock();

    public void performTask() throws InterruptedException {
        if (lock.tryLock(5, TimeUnit.SECONDS)) {
            try {
                // 成功获取锁，继续执行任务
            } finally {
                lock.unlock();
            }
        } else {
            // 获取锁超时，执行其他操作或报错
        }
    }
}