Java 中通过 key 获取锁的方法
一、概览
本文我们将了解如何通过特定键获取锁，以保证该键上的操作的线程安全，并且不妨碍其他键。
一般来说，我们需要实现两个方法：
void lock(String key) void unlock(String key)
本文以字符串作为键为例，大家可以根据实际需要改造成任意类型的键，重写 equas 和 hashCode 方法，保证唯一性即可。
二、简单的互斥锁
假设需要满足当前线程获取锁则需要执行特定代码，否则不执行这个场景。
我们可以维护一系列 Key 的 Set, 在使用时添加到 Set 中，解锁时移除对应的 Key。
此时，需要考虑线程安全问题。因此需要使用线程安全的 Set 实现，如基于 ConcurrentHashMap 的线程安全 Set。
public class SimpleExclusiveLockByKey {
private static Set<String> usedKeys= ConcurrentHashMap.newKeySet();
public boolean tryLock(String key) {
return usedKeys.add(key);
}
public void unlock(String key) {
usedKeys.remove(key);
}
}使用案例：
String key = "key";
SimpleExclusiveLockByKey lockByKey = new SimpleExclusiveLockByKey();
try {
lockByKey.tryLock(key);
// 在这里添加对该 key 获取锁之后要执行的代码
} finally { // 非常关键
lockByKey.unlock(key);
}注意一定要在 finally 代码块中解锁，以保证即便发生异常时，也可以正常解锁。
三、按键来获取和释放锁
以上代码可以保证获取锁后才执行，但无法实现未拿到锁的线程等待的效果。
有时候，我们需要让未获取到对应锁的线程等待。
流程如下：
- 第一个线程获取某个 key 的锁
- 第二个线程获取同一个 key 的锁，第二个线程需要等待
- 第一个线程释放某个 key 的锁
- 第二个线程获取该 key 的锁，然后执行其代码
3.1 使用线程计数器定义 Lock
我们可以使用 ReentrantLock 来实行线程阻塞。
我们通过内部类来封装 Lock。该类统计某个 key 上执行的线程数。暴露两个方法，一个是线程数增加，一个是减少线程数。
private static class LockWrapper {
private final Lock lock = new ReentrantLock();
private final AtomicInteger numberOfThreadsInQueue = new AtomicInteger(1);
private LockWrapper addThreadInQueue() {
numberOfThreadsInQueue.incrementAndGet();
return this;
}
private int removeThreadFromQueue() {
return numberOfThreadsInQueue.decrementAndGet();
}
}3.2 处理排队的线程
接下来继续使用 ConcurrentHashMap ， key 作为键， LockWrapper 作为值。
保证同一个 key 使用同一个 LockWrapper 中的同一把锁。
private static ConcurrentHashMap<String, LockWrapper> locks = new ConcurrentHashMap<String, LockWrapper>();
一个线程想要获取某个 key 的锁时，需要看该 key 对应的 LockWrapper 是否已经存在。
- 如果不存在，创建一个 LockWrapper ，计数器设置为1
- 如果存在，对应的 LockWrapper 加1
public void lock(String key) {
LockWrapper lockWrapper = locks.compute(key, (k, v) -> v == null ? new LockWrapper() : v.addThreadInQueue());
lockWrapper.lock.lock();
}3.3 解锁和移除 Entry
解锁时将等待的队列减一。
当前 key 对应的线程数为 0 时，可以将其从 ConcurrentHashMap 中移除。
public void unlock(String key) {
LockWrapper lockWrapper = locks.get(key);
lockWrapper.lock.unlock();
if (lockWrapper.removeThreadFromQueue() == 0) {
// NB : We pass in the specific value to remove to handle the case where another thread would queue right before the removal
locks.remove(key, lockWrapper);
}
}3.4 总结
最终效果如下：
public class LockByKey {
private static class LockWrapper {
private final Lock lock = new ReentrantLock();
private final AtomicInteger numberOfThreadsInQueue = new AtomicInteger(1);
private LockWrapper addThreadInQueue() {
numberOfThreadsInQueue.incrementAndGet();
return this;
}
private int removeThreadFromQueue() {
return numberOfThreadsInQueue.decrementAndGet();
}
}
private static ConcurrentHashMap<String, LockWrapper> locks = new ConcurrentHashMap<String, LockWrapper>();
public void lock(String key) {
LockWrapper lockWrapper = locks.compute(key, (k, v) -> v == null ? new LockWrapper() : v.addThreadInQueue());
lockWrapper.lock.lock();
}
public void unlock(String key) {
LockWrapper lockWrapper = locks.get(key);
lockWrapper.lock.unlock();
if (lockWrapper.removeThreadFromQueue() == 0) {
// NB : We pass in the specific value to remove to handle the case where another thread would queue right before the removal
locks.remove(key, lockWrapper);
}
}
}
使用示例：
String key = "key";
LockByKey lockByKey = new LockByKey();
try {
lockByKey.lock(key);
// insert your code here
} finally { // CRUCIAL
lockByKey.unlock(key);
}四、允许同一个 key 同时多个线程运行
我们还需要考虑另外一种场景： 前面对于同一个 key 同一时刻只允许一个线程执行。如果我们想实现，对于同一个 key ，允许同时运行 n 个线程该怎么办？
为了方便理解，我们假设同一个 key 允许两个线程。
- 第一个线程想要获取 某个 key 的锁，允许
- 第二个线程也想要获取该 key 的锁，允许
- 第三个线程也想获取该 key 的锁，该线程需要等待第一个或第二个线程释放锁之后才可以执行
Semaphore 很适合这种场景。Semaphore 可以控制同时运行的线程数。
public class SimultaneousEntriesLockByKey {
private static final int ALLOWED_THREADS = 2;
private static ConcurrentHashMap<String, Semaphore> semaphores = new ConcurrentHashMap<String, Semaphore>();
public void lock(String key) {
Semaphore semaphore = semaphores.compute(key, (k, v) -> v == null ? new Semaphore(ALLOWED_THREADS) : v);
semaphore.acquireUninterruptibly();
}
public void unlock(String key) {
Semaphore semaphore = semaphores.get(key);
semaphore.release();
if (semaphore.availablePermits() == ALLOWED_THREADS) {
semaphores.remove(key, semaphore);
}
}
}使用案例：
String key = "key";
SimultaneousEntriesLockByKey lockByKey = new SimultaneousEntriesLockByKey();
try {
lockByKey.lock(key);
// 在这里添加对该 key 获取锁之后要执行的代码
} finally { // 非常关键
lockByKey.unlock(key);
}五、结论
本文演示如何对某个 key 加锁，以保证对该 key 的并发操作限制，可以实现同一个 key 一个或者多个线程同时执行。
相关代码：https://github.com/eugenp/tutorials/tree/master/core-java-modules/core-java-concurrency-advanced-4
原文：https://www.baeldung.com/java-acquire-lock-by-key
到此这篇关于Java 中通过 key 获取锁的文章就介绍到这了,更多相关java 获取锁内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要介绍了Spring Boot Admin邮件警报整合过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-03-03
这篇文章主要为大家详细介绍了基于swing实现窗体拖拽和拉伸，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2017-12-12
这篇文章主要介绍了Android设备如何保证数据同步写入磁盘的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2019-09-09
这篇文章主要介绍了Java基于Tcp协议的socket编程实例,较为详细的分析了socket编程客户端与服务器端的具体实现步骤与使用技巧,具有一定的参考借鉴价值,需要的朋友可以参考下2014-12-12
Spring Boot/Angular整合Keycloak实现单点登录功能
Keycloak新的发行版命名为Quarkus，专为GraalVM和OpenJDK HotSpot量身定制的一个Kurbernetes Native Java框架，计划2019年底正式发布。这篇文章主要介绍了Spring Boot/Angular整合Keycloak实现单点登录,需要的朋友可以参考下2019-10-10
这篇文章主要介绍了详解Java的Spring框架中bean的注入集合,Spring是Java的SSH三大web开发框架之一,需要的朋友可以参考下2015-12-12
springboot嵌套子类使用方式—前端与后台开发的注意事项
这篇文章主要介绍了springboot嵌套子类使用方式—前端与后台开发的注意事项，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2022-03-03
TransactionSynchronization的invokeAfterCompletion事务源码解析
这篇文章主要为大家介绍了TransactionSynchronization的invokeAfterCompletion事务源码解析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪2023-09-09
Intellij IDEA 2017新特性之Spring Boot相关特征介绍
Intellij IDEA 2017.2.2版本针对Springboot设置了一些特性，本篇文章给大家简单介绍一下如何使用这些特性，需要的朋友参考下吧2018-01-01
一些面试官可能在面试Java基础的时候,让你说一下字符串反转,会手撕代码,所以下面这篇文章主要给大家介绍了关于Java字符串中指定部分反转的三种方式,需要的朋友可以参考下2022-01-01
最新评论