Java多线程并发之ReentrantLock

概述

在java中，多线程并发编程是非常重要的一部分，而ReentrantLock是一种替代Synchronized关键词的工具，可以用于线程同步，实现线程安全和资源竞争控制。

相对于Synchronized关键词，ReentrantLock在性能上更加优越，更加灵活，具有更强的扩展性和可重入性。

本文将对ReentrantLock进行详细讲解，包括使用方法、应用场景、要点等内容。

使用方法

ReentrantLock使用方法和Synchronized关键词非常相似，可以通过锁住一个对象来进行多线程同步。

使用ReentrantLock的过程可以分为以下几个步骤：

1. 在线程要使用资源前，创建一个ReentrantLock对象作为竞争资源锁；

2. 在需要同步的代码块前，调用ReentrantLock对象的lock()方法锁定资源；

3. 在使用完资源后，调用ReentrantLock对象的unlock()方法释放资源锁。

下面是基本的示例代码：

import java.util.concurrent.locks.ReentrantLock;

public class ThreadLockTest {
    private static final ReentrantLock lock = new ReentrantLock();// 创建锁对象
    private static int age = 0;// 全局变量

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();// 锁定资源
                    try {
                        age++;// 修改全局变量
                        System.out.println(Thread.currentThread().getName() + " age:" + age);
                    } finally {
                        lock.unlock();// 释放锁
                    }
                }
            }).start();
        }
    }
}

注意点

使用ReentrantLock时需要注意以下几点：

1. 实例化对象的重要性

在创建ReentrantLock对象时，应当单独创建其实例，每个线程共享一个ReentrantLock对象时，锁无法实现同步。二者会分别拥有自己的计数器和标识锁是否被占用的标志位，不会相互干扰。

2. 锁的可重入性

ReentrantLock是一种可重入的锁，允许一个线程重复获得同一个锁。因为每次锁上都增加了计数器，和标识锁是否被占用的标志位，本质上和多把锁进行竞争没有区别。这样，在同一个线程中可以出现以下代码：

lock.lock();
try {
    // do something
    lock.lock();
    try {
        // do something again
    } finally {
        lock.unlock();
    }
} finally {
    lock.unlock();
}

3. 释放锁的注意事项

要在正确的位置解锁，一旦ReentrantLock被解锁，其它线程才能访问共享资源，在解锁的时候需要保证锁一定会被释放掉。

应用场景

ReentrantLock可以用于以下几个方面：

1. 读写锁

可以使用ReentrantReadWriteLock类，让多个线程同时读取一个资源，但是写操作是排它性的。

2. 死锁避免

在使用Synchronized关键词锁时，如果两个线程分别等待对方释放锁，就会发生死锁。ReentrantLock提供了lockInterruptibly()方法和tryLock()方法，可以避免死锁发生。

3. 限时等待

在某些场景下，需要等待一段时间后就要获取锁，一般是通过sleep的方式来实现，而ReentrantLock提供了一个更加灵活的方式：tryLock(long time, TimeUnit unit)方法。

示例说明

接下来是两个界面多线程禁止操作的示例。

界面多线程禁止操作之弹窗模式

常见的应用场景是在一个界面下，点击某个按钮，需要进行异步操作，并且在操作完成前禁止其它操作，防止用户误触。

此时可以通过以下代码来实现：

private void asyncOperate() {
    final ReentrantLock lock = new ReentrantLock();// 创建锁对象
    lock.lock();// 锁定资源
    try {
        // 显示加载弹窗
        // ...
        new Thread(new Runnable() {
            @Override
            public void run() {
                 // 异步操作
                 // ...

                // 关闭加载弹窗
                // ...
                lock.unlock();// 释放锁
            }
        }).start();
    } finally {
        lock.unlock();// 释放锁
    }
}

在点击按钮时获取锁，然后在异步操作中释放锁，这样其它操作就无法干扰到异步操作的执行。

界面多线程禁止操作之嵌套模式

在某些场景下，一个界面的某个操作需要对多个操作的可执行性状态进行操作，需要通过ReentrantLock进行嵌套处理。

private void operate1() {
    final ReentrantLock lock = new ReentrantLock();// 创建锁对象
    lock.lock();// 锁定资源
    try {
        operate2();
        // ...
    } finally {
        lock.unlock();// 释放锁
    }
}

private void operate2() {
    final ReentrantLock lock = new ReentrantLock();// 创建锁对象
    lock.lock();// 锁定资源
    try {
        // ...
        operate3();
        // ...
    } finally {
        lock.unlock();// 释放锁
    }
}

private void operate3() {
    final ReentrantLock lock = new ReentrantLock();// 创建锁对象
    lock.lock();// 锁定资源
    try {
        // ...
    } finally {
        lock.unlock();// 释放锁
    }
}

在多个嵌套方法中都使用了ReentrantLock进行同步，能够避免在嵌套调用中出现锁竞争和死锁的情况。

总结

ReentrantLock是一种非常优秀的线程同步工具，相对于Synchronized关键词来说有着更大的灵活性和可重入性。

在Java多线程编程中，ReentrantLock的使用是至关重要的，在一些场景下甚至是必不可少的。

如果你想提高Java多线程并发编程的水平，ReentrantLock的使用是必须掌握的。