JAVA多线程并发（六）-- ReentrantLock、Semaphore、CountDownLatch 简介

一、ReentrantLock （可重入锁）

1. ReentrantLock简介
   ReentrantLock是Java中的一个可重入锁，它实现了Lock接口，并且支持公平锁和非公平锁。ReentrantLock的“可重入”意味着同一个线程可以多次获得同一把锁。
2. ReentrantLock 与 synchronized 区别
   ReentrantLock 和 synchronized 都是 Java 中用于实现线程同步的机制，悲观锁,但它们在使用方式、功能和灵活性上有一些不同。

• 可重入性：

  • ReentrantLock 是可重入的，也就是说，同一个线程可以多次获取同一个锁而不会导致死锁。
  • synchronized 也是可重入的，同一个线程可以多次获取同一个对象的锁，而不会造成死锁。

• 获取锁的方式：

  • 使用 ReentrantLock，需要显式地调用 lock() 方法来获取锁，并且在使用完毕后要记得调用 unlock() 方法释放锁。
  • 使用 synchronized，锁的获取和释放是隐式的，当进入 synchronized 块时自动获取锁，块执行完毕后自动释放锁。

• 灵活性：

  • ReentrantLock 提供了更多的灵活性，例如，可以设置超时时间、中断响应等。
  • synchronized 相对来说比较简单，不能设置超时等待，也不能响应中断。
    性能：

• 可中断性：

  • ReentrantLock 提供了 lockInterruptibly() 方法，可以响应中断。
  • synchronized 块不支持中断，如果一个线程在 synchronized 块中被阻塞，无法被中断。

3.公平锁与非公平锁：
ReentrantLock支持公平锁和非公平锁。公平锁会按照线程请求锁的顺序来分配锁，而非公平锁则可能允许刚刚释放锁的线程再次获得锁。默认情况下，ReentrantLock创建的是非公平锁。
4.加锁与解锁过程：
加锁过程涉及到线程的等待队列和状态变更，而非公平锁和公平锁在加锁时的主要区别在于线程获取锁的顺序。解锁过程则相对简单，主要是将当前线程从锁的持有者中移除，并唤醒等待队列中的其他线程。

5. 使用ReentrantLock
在Spring应用中，我们可以使用ReentrantLock来实现对共享资源的线程安全访问。下面是一个简单的示例，演示了如何在Spring中使用ReentrantLock来保护一个共享资源：

import org.springframework.stereotype.Component;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Component
public class SharedResource {
    private final Lock lock = new ReentrantLock();
    private int count = 0;

    public int incrementAndGet() {
        lock.lock();
        try {
            return ++count;
        } finally {
            lock.unlock();
        }
    }
}

在上面的示例中，SharedResource类包含一个共享资源count，通过ReentrantLock来保护对count的并发访问。incrementAndGet()方法使用了ReentrantLock来确保对count的原子性增加操作。

二、Semaphore

1. Semaphore通常被称为信号量，它用来控制同时访问特定资源的线程数量。Semaphore内部维护了一个计数器，表示当前可用的许可数（即允许同时访问资源的线程数）。当一个线程需要访问资源时，它会尝试获取一个许可；如果计数器大于0，则获取成功并计数器减一；如果计数器为0，则线程需要等待直到有其他线程释放许可。
2. 使用场景：
   Semaphore常用于控制同时访问某个资源的线程数量。下面是一个示例，演示了如何在Spring中使用Semaphore来限制对某个资源的并发访问数量：

import org.springframework.stereotype.Component;
import java.util.concurrent.Semaphore;

@Component
public class ResourcePool {
    private final Semaphore semaphore = new Semaphore(5); // 限制同时访问资源的线程数量为5

    public void accessResource() throws InterruptedException {
        semaphore.acquire();
        try {
            // 访问共享资源的代码
            System.out.println("Thread " + Thread.currentThread().getId() + " is accessing the resource.");
            Thread.sleep(1000); // 模拟访问资源的耗时操作
        } finally {
            semaphore.release();
        }
    }
}

在上面的示例中，ResourcePool类维护了一个Semaphore对象，限制了同时访问资源的线程数量为5。accessResource()方法通过semaphore.acquire()获取许可证，然后访问共享资源，最后通过semaphore.release()释放许可证。

三、 CountDownLatch （倒计时门闩）

CountDownLatch是Java中的一个同步工具类，主要用来解决多线程之间的协同工作问题。它允许一个或多个线程等待其他一组线程完成操作。CountDownLatch使用一个计数器来初始化需要等待的线程数量，每当一个线程完成了它的任务，计数器就会递减；当计数器归零时，意味着所有需要等待的线程都已经完成了它们的任务，此时等待的线程就可以继续执行了。

使用场景：
CountDownLatch常用于需要在多个线程完成一系列操作后才能继续执行的场景，例如在一个多阶段的任务中，可能需要等待所有的数据预处理线程都完成后，再启动一个线程来进行数据汇总。下面是一个示例，演示了如何在Spring中使用CountDownLatch来实现等待一组任务完成后再执行主线程：

import org.springframework.stereotype.Component;
import java.util.concurrent.CountDownLatch;

@Component
public class TaskRunner {
    private final CountDownLatch latch = new CountDownLatch(3); // 初始化CountDownLatch为3

    public void runTasks() throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                // 执行任务
                System.out.println("Thread " + Thread.currentThread().getId() + " is running a task.");
                latch.countDown(); // 每个任务执行完毕后减少CountDownLatch的计数
            }).start();
        }
        latch.await(); // 等待所有任务执行完毕
        System.out.println("All tasks have been completed.");
    }
}

在上面的示例中，TaskRunner类维护了一个CountDownLatch对象，初始化为3。runTasks()方法创建了三个线程来执行任务，并且每个任务执行完毕后会调用latch.countDown()来减少CountDownLatch的计数。主线程通过latch.await()来等待所有任务执行完毕后再继续执行。