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

Myth丶恋晨 2023-10-16 11:36 82阅读 0赞

![在这里插入图片描述][c9b538446ac047cf867b0d31c3d380e1.png]

在多线程编程中，线程同步是一个重要的话题。为了确保多个线程可以正确地协同工作，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 {
        
                // 获取锁超时，执行其他操作或报错
            }
        }
    }

在上述示例中，`tryLock`方法会尝试获取锁，如果在指定的超时时间内未成功获取锁，则会返回`false`，可以根据返回值执行相应的操作。

### 总结 ###

`Lock`接口是Java提供的一种强大的线程同步机制，它允许更灵活的锁定和解锁操作，支持可重入性、公平锁、条件变量、超时获取锁等高级特性，使得多线程编程更加方便和可控。

在使用`Lock`接口时，需要小心设计，以确保线程安全性和程序的正确性。选择合适的锁定策略、使用条件变量等都需要根据具体的需求来决定。

希望本文对您理解Java中的`Lock`接口和线程同步有所帮助。谢谢阅读！

[c9b538446ac047cf867b0d31c3d380e1.png]: https://img-blog.csdnimg.cn/c9b538446ac047cf867b0d31c3d380e1.png