Java并发—ReetrantLock详解

一、ReetrantLock的特性

1、非阻塞获取锁

2、带超时的锁获取:

3、锁的公平性

4、锁的可中断性

5、Condition条件变量

6、锁的可重入性

可重入锁

不可重入锁

7、性能优化

二、ReentrantLock和Synchronized的区别

1、语法和使用方式

2、锁的获取和释放

3、高级特性

4、条件变量

5、性能

总结

三、ReentrantLock使用场景

之前的文章Java并发—synchronized关键字的应用-CSDN博客讲述了sychronized的应用，那为什么还需要其他的锁呢？

synchronized属于隐式锁，即锁的持有与释放都是隐式的，可能会导致死锁

为了可以灵活地控制锁，就需要使用到显式锁，即锁的持有和释放都必须手动编写

其他锁如 ReentrantLock 提供了更高级的功能，如公平锁、超时等待和可中断等待

在Java 1.5中，官方在concurrent并发包中加入了Lock接口，该接口中提供了lock()方法和unLock()方法对显式加锁和显式释放锁操作进行支持

Lock lock = new ReentrantLock();
 
public void save(){
    try{
        lock.lock();
        //业务代码……
    }finally{
        lock.unlock();
    }
}

从上述代码可以使用ReentrantLock来管理锁，确保在save方法执行期间对资源的独占访问。通过try-finally结构确保即使发生异常也能正确地使用lock.unlock()释放锁

ReentrantLock实现了Lock接口，Lock接口是Java中对锁操作行为的统一规范

ReentrantLock结构：

一、ReetrantLock的特性

不仅如此，ReetrantLock相对于synchronized解决了很多问题：

上述代码lock.lock();会阻塞当前线程直至获取到锁为止，那么为了避免这个问题就需要使用lock.tryLock()

1、非阻塞获取锁

ReentrantLock提供了tryLock()方法，可以尝试获取锁而不阻塞当前线程。

如果锁当前未被任何线程持有，则tryLock()方法会立即获取锁并返回true。
如果锁当前已被其他线程持有，则tryLock()方法不会阻塞当前线程，而是立即返回false。

代码如下：

     import java.util.concurrent.locks.ReentrantLock;

     public class DemoService {

         //将ReentrantLock实例声明为final可以确保锁对象的不变性，提高线程安全性
         private final ReentrantLock lock = new ReentrantLock();

         public void save() {
             try {
                 lock.lock();
                 // 业务代码……
             } finally {
                 lock.unlock();
             }
         }
     }

2、带超时的锁获取:

ReentrantLock提供了tryLock(long timeout, TimeUnit unit)方法，允许线程在指定时间内尝试获取锁

如果在指定时间内未能获取到锁，则线程不会被阻塞，而是返回false

🌰：多线程获取超时锁的案例

     public class TryLockWithTimeoutExample {

         private final ReentrantLock lock = new ReentrantLock();

         public void save() {
             if (!lock.tryLock(5, TimeUnit.SECONDS)) {
                 // 如果未能在5秒内获取锁，可以记录日志或采取其他措施
                 return; // 或者抛出异常
             }

             try {
                 // 业务代码……
             } catch (Exception e) {
                 // 处理异常
                 throw e;
             } finally {
                 lock.unlock();
             }
         }

         public static void main(String[] args) {
             TryLockWithTimeoutExample example = new TryLockWithTimeoutExample();
             new Thread(example::save).start();
             new Thread(example::save).start();
         }
     }

3、锁的公平性

ReentrantLock允许创建公平锁或非公平锁

公平锁：按照线程请求锁的顺序来分配锁，可以减少线程之间的饥饿现象。保证等待时间最长的线程优先获取锁，其实就是先入队的先得锁，即FIFO
非公平锁：不保证请求锁的顺序，可能会让后来的线程优先获取锁

公平锁常见的场景：多线程任务顺序处理、线程池

默认情况下ReentrantLock使用非公平锁

/**
 * 默认创建非公平锁
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 * fair为true表示是公平锁，fair为false表示是非公平锁
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

🌰：多线程获取公平锁的案例

public class FairReentrantLockExample {

    private final ReentrantLock lock = new ReentrantLock(true); // true 表示公平锁

    public void processTask(int taskId) {
        lock.lock();
        try {
            System.out.println("Processing task " + taskId + " by " + Thread.currentThread().getName());
            // 业务代码……
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        FairReentrantLockExample example = new FairReentrantLockExample();
        
        for (int i = 1; i <= 5; i++) {
            int taskId = i;
            new Thread(() -> example.processTask(taskId)).start();
        }
    }
}

执行顺序：

创建线程：主线程创建5个新线程，每个线程都会调用 processTask()，线程被创建后，它们就会被加入到线程调度器的就绪队列中，等待被调度执行
请求锁
- 每个线程开始执行时，都会尝试获取锁
- 由于使用的是公平锁，线程将按照它们请求锁的顺序来获取锁
执行过程
- 线程1首先调度执行，如果获取到锁开始执行processTask()
- 其他线程将被阻塞，直至锁可用的状态
- 线程1执行完执行processTask()，释放锁
- 线程2请求锁，获取锁开始执行processTask()，此过程将重复，直至所有线程都执行完毕

效果：

Processing task 1 by Thread-0
Processing task 2 by Thread-1
Processing task 3 by Thread-2
Processing task 4 by Thread-3
Processing task 5 by Thread-4

例如：可以使线程池中的线程公平地获取锁，以确保线程按照一定的顺序获取锁，从而避免某些线程长时间无法获取锁导致的饥饿问题

🌰：线程池使用公平锁

     public class FairReentrantLockThreadPoolExample {

         private final ReentrantLock lock = new ReentrantLock(true); // true 表示公平锁
         private final ExecutorService executor = Executors.newFixedThreadPool(3);

         public void processTask(int taskId) {
             lock.lock();
             try {
                 System.out.println("Processing task " + taskId + " by " + Thread.currentThread().getName());
                 // 业务代码……
             } finally {
                 lock.unlock();
             }
         }

         public static void main(String[] args) {
             FairReentrantLockThreadPoolExample example = new FairReentrantLockThreadPoolExample();
             
             for (int i = 1; i <= 5; i++) {
                 int taskId = i;
                 executor.execute(() -> example.processTask(taskId));
             }
             
             // 关闭线程池
             executor.shutdown();
         }
     }

说明：在这个例子中，我们创建了一个固定大小的线程池，其中包含3个线程

线程池将处理5个任务，每个任务都需要获取公平锁。由于线程池的大小为3，最多只有3个线程可以同时执行

当一个线程获取锁后，其他线程将被阻塞，直到锁被释放。由于使用了公平锁，线程将按照它们请求锁的顺序来获取锁

4、锁的可中断性

使用ReentrantLock时，线程可以通过中断机制来取消等待锁的操作，避免线程阻塞

lock.lockInterruptibly()获取一个可以被中断的重入锁，允许线程在等待锁的过程中响应中断信号，使用thread.interrupt()可以打断线程

🌰：多线程执行业务时被中断

     public class InterruptibleLockExample {

         private final ReentrantLock lock = new ReentrantLock();
         private final Condition condition = lock.newCondition();

         public void processTask()  {
            try {
                lock.lockInterruptibly();
                System.out.println("Processing task by " + Thread.currentThread().getName());
                // 业务代码……
                // 假设需要等待一段时间
                condition.await(5, TimeUnit.SECONDS);
                System.out.println("Task completed by " + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " interrupted, task cancelled");
            } finally {
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + " released the lock");
            }
        }

         public static void main(String[] args) throws InterruptedException {
             InterruptibleLockExample example = new InterruptibleLockExample();

             Thread thread = new Thread(example::processTask);
             thread.start();

             // 假设我们需要在一段时间后中断线程
             TimeUnit.SECONDS.sleep(2);
             thread.interrupt();
         }
     }

线程调用 condition.await(5, TimeUnit.SECONDS) 开始等待 5 秒。在等待过程中，主线程在 2 秒后中断了 Thread-0。Thread-0 在等待过程中被中断，因此将抛出 Interrup如果线程被中断，将抛出 InterruptedException，线程中断退出

效果：

Processing task by Thread-0
Thread-0 interrupted, task cancelled
Thread-0 released the lock

5、Condition条件变量

ReentrantLock支持条件变量，允许线程等待特定条件满足后再继续执行

Condition 接口是 Java 1.5 中引入的 java.util.concurrent 包的一部分，旨在提供更高级别的并发控制，设计目的是为了提供比 wait 和 notify 更加灵活和强大的线程同步机制

Condition 接口允许更细粒度的控制，比如可以有多个条件变量，每个条件变量可以独立使用，从而支持更复杂的同步模式

提供了 await、signal 和 signalAll 等方法。

await 方法释放锁并等待，直到被 signal 或 signalAll 方法唤醒。
signal 方法唤醒一个等待线程，而 signalAll 方法唤醒所有等待线程。
Condition 对象可以与多个锁关联，因此可以实现多个条件变量。

Condition接口可以与ReentrantLock一起使用，提供了更灵活的线程同步机制。

private final ReentrantLock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();

在上述线程中断的案例中，也使用了Condition的await()

// 假设需要等待5s时间
condition.await(5, TimeUnit.SECONDS);

通过Condition接口定义的方法我们发现跟之前Object的wait和notify功能几乎差不多，所以使用Condition对象的方法也可以完成线程间的通信

wait 和 notify 方法：

必须在一个已经同步的对象上调用，即必须在 synchronized 块或方法中使用。
wait 方法释放锁并等待，直到被 notify 或 notifyAll 方法唤醒。
notify 方法随机唤醒一个等待线程，而 notifyAll 方法唤醒所有等待线程。只能使用一个同步对象来控制多个线程之间的同步

6、锁的可重入性

锁的可重入性和不可重入性主要描述了一个线程在获取锁之后是否能够再次获取同一把锁而不引起死锁的能力

可重入锁

可重入锁允许一个已经获取了锁的线程再次获取同一把锁，而不会导致其他等待该锁的线程被阻塞

因为可重入锁内部维护了一个计数器，每当同一个线程再次获取锁时，计数器加一；当线程释放锁时，计数器减一，直到计数器为零时，锁才真正被释放

ReentrantLock支持可重入性，即允许已经持有锁的线程再次获取锁。

这种特性在synchronized中也是支持的，但在ReentrantLock中更为明显和可控

🌰：假设一个银行账户需要有存款和取款的操作

先使用synchronized实现重入锁

public class Account {
    private int balance = 0;

    public synchronized void deposit(int amount) {
        balance += amount;
        // 假设我们想在存款后打印余额
        printBalance();
    }

    public synchronized void withdraw(int amount) {
        if (amount <= balance) {
            balance -= amount;
        }
        // 假设我们想在取款后打印余额
        printBalance();
    }

    public synchronized void printBalance() {
        System.out.println("当前余额: " + balance);
    }
}

在这个例子中，deposit 和 withdraw 方法都是同步的，这意味着它们只能由一个线程执行。同样，printBalance 方法也是同步的，这样当一个线程正在执行 deposit 或 withdraw 方法时，它可以安全地调用 printBalance 方法而不会导致死锁

使用ReentrantLock实现重入锁

public class Account {
    private int balance = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void deposit(int amount) {
        lock.lock();
        try {
            balance += amount;
            // 假设我们想在存款后打印余额
            printBalance();
        } finally {
            lock.unlock();
        }
    }

    public void withdraw(int amount) {
        lock.lock();
        try {
            if (amount <= balance) {
                balance -= amount;
            }
            // 假设我们想在取款后打印余额
            printBalance();
        } finally {
            lock.unlock();
        }
    }

    public void printBalance() {
        lock.lock();
        try {
            System.out.println("当前余额: " + balance);
        } finally {
            lock.unlock();
        }
    }
}

假设初始余额为 0，并且线程 T1 先执行 deposit(100)，接着线程 T2 执行 withdraw(50)，最后线程 T3 执行 printBalance()，那么输出可能是：

当前余额: 100
当前余额: 50

不可重入锁

不可重入锁不允许一个已经获取了锁的线程再次获取同一把锁，除非它首先释放了锁。如果一个线程试图再次获取锁，它将会被阻塞，直到锁被释放。这种类型的锁通常用于那些不需要支持递归调用的场景

由于 Java 标准库中没有直接提供的不可重入锁实现，我们可以使用 java.util.concurrent.locks.Lock 接口的实现类来模拟一个不可重入锁的行为。这里我们使用 ReentrantLock 并手动管理锁的可重入性

import java.util.concurrent.locks.ReentrantLock;

public class NonReentrantAccount {
    private int balance = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void deposit(int amount) {
        lock.lock();
        try {
            balance += amount;
            // 假设我们想在存款后打印余额
            printBalance();
        } finally {
            lock.unlock();
        }
    }

    public void withdraw(int amount) {
        lock.lock();
        try {
            if (amount <= balance) {
                balance -= amount;
            }
            // 假设我们想在取款后打印余额
            printBalance();
        } finally {
            lock.unlock();
        }
    }

    public void printBalance() {
        // 模拟不可重入锁行为，检查当前线程是否持有锁
        if (!lock.isHeldByCurrentThread()) {
            lock.lock();
            try {
                System.out.println("当前余额: " + balance);
            } finally {
                lock.unlock();
            }
        } else {
            // 如果当前线程已经持有锁，则不打印余额
            // 这里我们简单地跳过打印操作
        }
    }
}

使用 ReentrantLock 来实现锁的功能，但是在 printBalance 方法中，我们检查当前线程是否已经持有锁。如果是，则不执行打印操作，以此来模拟不可重入锁的行为

假设初始余额为 0，并且线程 T1 先执行 deposit(100)，接着线程 T2 执行 withdraw(50)，最后线程 T3 执行 printBalance()，那么输出可能是：

当前余额: 50

这是因为：

线程 T1 执行 deposit(100)，此时T1持有锁，因此 printBalance 不会被执行
线程 T2 执行 withdraw(50)，T1释放锁，T2持有锁，因此 printBalance 不会被执行
线程 T3 执行 printBalance()，此时T3不持有锁，因此会先获取锁并打印当前余额 50

⚠️注意：实际应用中很少会使用这样的不可重入锁实现，因为这通常会导致代码难以理解和维护。通常情况下，更倾向于使用可重入锁来避免死锁问题