掌握ReentrantLock与Semaphore，提升开发效率！

掌握ReentrantLock与Semaphore，提升开发效率！

引用

github

等

17

来源

1.

https://github.com/h2pl/JavaTutorial/blob/master/docs/Java/concurrency/Java%E5%B9%B6%E5%8F%91%E6%8C%87%E5%8D%97%EF%BC%9AJava%E4%B8%AD%E7%9A%84%E9%94%81Lock%E5%92%8Csynchronized.md

2.

https://cloud.baidu.com/article/3221885

3.

https://dev.to/mjsf1234/mastering-java-concurrency-dive-into-part-2-39n3

4.

https://blog.csdn.net/yangyufneg/article/details/136718240

5.

https://blog.csdn.net/qqrrjj2011/article/details/136030479

6.

https://www.jianshu.com/p/5eece737db30

7.

https://docs.semaphoreui.com/

8.

https://30dayscoding.com/blog/java-concurrency-locks-semaphores-monitors

9.

https://getlearntech.com/reentrantlock-in-java/

10.

https://www.zhiqu.org/hu-vv8n85nx88k5vnv38vk.html

11.

https://code-maze.com/semaphore-introduction-csharp/

12.

https://javanexus.com/blog/deadlock-prevention-reentrant-locks

13.

https://docs.semaphoreui.com/administration-guide/installation/

14.

https://docs.semaphoreui.com/user-guide/inventory/

15.

https://www.baeldung.com/java-concurrent-locks

16.

https://developer.aliyun.com/article/1509830

17.

https://semaphoreci.com/blog/rules-ci-pipeline

在Java多线程编程中，ReentrantLock和Semaphore是两个非常重要的并发控制工具。它们各自具有独特的功能和适用场景，正确理解和使用这些工具对于编写高效、稳定的并发程序至关重要。

ReentrantLock：可重入的互斥锁

ReentrantLock是一种可重入的互斥锁，它允许多个线程中的同一个线程多次获取锁。与传统的synchronized关键字相比，ReentrantLock提供了更灵活的锁定机制，支持公平锁和非公平锁，并允许中断等待线程。

Semaphore：信号量

Semaphore用于控制同时访问特定资源的线程数量。它通过维护一个许可计数器来限制并发访问，适用于资源池或流量控制等场景。Semaphore可以设置为允许多个线程同时访问，具有共享特性。

用途不同

• ReentrantLock主要用于独占式资源访问，确保同一时间只有一个线程执行临界区代码。
• Semaphore则用于限制资源的并发访问数量，适合管理有限资源（如数据库连接）。

共享模式

• ReentrantLock是独占锁，一次仅允许一个线程持有。
• Semaphore可以设置为允许多个线程同时访问（当许可证数量大于1时），具有共享特性。

公平性支持

两者都支持公平模式，但默认是非公平的。ReentrantLock需要手动释放锁，而Semaphore通过acquire和release方法来控制资源访问。

ReentrantLock适用场景

当需要严格控制资源的独占访问时，ReentrantLock是理想的选择。例如，在处理高并发环境下的数据库操作或文件写入时，使用ReentrantLock可以确保数据的一致性和完整性。

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

Semaphore适用场景

当需要限制资源的并发访问数量时，Semaphore更为适用。例如，在管理数据库连接池时，可以使用Semaphore来控制同时访问数据库的线程数量。

import java.util.concurrent.Semaphore;

public class LimitedResourceAccess {
    private final Semaphore semaphore = new Semaphore(5); // 允许最多5个线程同时访问

    public void accessResource() {
        try {
            semaphore.acquire(); // 获取许可
            System.out.println(Thread.currentThread().getName() + " is accessing the resource.");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release(); // 释放许可
        }
    }
}

ReentrantLock使用建议

1. 确保锁的释放：在finally块中释放锁，防止资源泄露。
2. 选择合适的锁类型：根据应用场景选择公平锁或非公平锁。
3. 响应中断：在长时间等待锁的场景中，考虑使用可中断的锁获取方式。

Semaphore使用建议

1. 合理设置许可数量：根据资源容量和系统负载调整Semaphore的许可数量。
2. 及时释放许可：确保在资源使用完毕后及时释放Semaphore许可。
3. 避免死锁：注意Semaphore的acquire和release顺序，防止死锁发生。

ReentrantLock和Semaphore在Java并发编程中扮演着重要角色。ReentrantLock通过提供灵活的锁定机制，确保了资源的独占访问；而Semaphore则通过限制并发访问数量，有效地管理了有限资源。掌握这两种工具的使用，能够显著提升程序的并发性能和稳定性。在实际开发中，根据具体需求选择合适的工具，并遵循最佳实践，可以有效避免常见的并发问题，提高开发效率。