开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 其他教程 >  Java根据某个key加锁怎么实现

Java根据某个key加锁怎么实现

其他教程   发布日期：2023年08月31日   浏览次数：763次

本篇内容主要讲解“Java根据某个key加锁怎么实现”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Java根据某个key加锁怎么实现”吧!

    一、背景

    日常开发中，有时候需要根据某个 key 加锁，确保多线程情况下，对该 key 的加锁和解锁之间的代码串行执行。
    大家可以借助每个 key 对应一个 ReentrantLock ，让同一个 key 的线程使用该 lock 加锁；每个 key 对应一个 Semaphore ，让同一个 key 的线程使用 Semaphore 控制同时执行的线程数。

    二、参考代码

    接口定义

    1. public interface LockByKey<T> {
    3.     /**
    4.      * 加锁
    5.      */
    6.     void lock(T key);
    8.     /**
    9.      * 解锁
    10.      */
    11.     void unlock(T key);
    12. }

    2.1 同一个 key 只能一个线程执行

    2.1.1 代码实现

    每个 key 对应一个 ReentrantLock ，让同一个 key 的线程使用该 lock 加锁。

    1. import java.util.Map;
    2. import java.util.concurrent.ConcurrentHashMap;
    3. import java.util.concurrent.locks.ReentrantLock;
    5. public class DefaultLockByKeyImpl<T> implements LockByKey<T> {
    7.     private final Map<T, ReentrantLock> lockMap = new ConcurrentHashMap<>();
    9.     /**
    10.      * 加锁
    11.      */
    12.     @Override
    13.     public void lock(T key) {
    14.         // 如果key为空，直接返回
    15.         if (key == null) {
    16.             throw new IllegalArgumentException("key 不能为空");
    17.         }
    18.         
    19.         // 获取或创建一个ReentrantLock对象
    20.         ReentrantLock lock = lockMap.computeIfAbsent(key, k -> new ReentrantLock());
    21.         // 获取锁
    22.         lock.lock();
    23.     }
    26.     /**
    27.      * 解锁
    28.      */
    29.     @Override
    30.     public void unlock(T key) {
    31.         // 如果key为空，直接返回
    32.         if (key == null) {
    33.             throw new IllegalArgumentException("key 不能为空");
    34.         }
    36.         // 从Map中获取锁对象
    37.         ReentrantLock lock = lockMap.get(key);
    38.         // 获取不到报错
    39.         if (lock == null) {
    40.             throw new IllegalArgumentException("key " + key + "尚未加锁");
    41.         }
    42.         // 其他线程非法持有不允许释放
    43.         if (!lock.isHeldByCurrentThread()) {
    44.             throw new IllegalStateException("当前线程尚未持有，key:" + key + "的锁，不允许释放");
    45.         }
    46.         lock.unlock();
    47.     }
    48. }

    注意事项：
    （1）参数合法性校验
    （2）解锁时需要判断该锁是否为当前线程持有

    2.1.2 编写单测

    1. import com.google.common.collect.Lists;
    2. import org.junit.Test;
    4. import java.util.HashSet;
    5. import java.util.List;
    6. import java.util.Set;
    7. import java.util.concurrent.CountDownLatch;
    8. import java.util.concurrent.ExecutorService;
    9. import java.util.concurrent.Executors;
    10. import java.util.concurrent.TimeUnit;
    12. public class DefaultLockByKeyImplTest {
    14.     private final LockByKey<String> lockByKey = new DefaultLockByKeyImpl<>();
    16.     private final CountDownLatch countDownLatch = new CountDownLatch(7);
    17.     private final ExecutorService executorService = Executors.newFixedThreadPool(10);
    19.     @Test
    20.     public void test() throws InterruptedException {
    21.         List<String> keys = Lists.newArrayList("a", "a", "a", "b", "c", "b", "d");
    22.         Set<String> executingKeySet = new HashSet<>();
    24.         for (int i = 0; i < keys.size(); i++) {
    25.             String key = keys.get(i);
    26.             int finalI = i;
    27.             executorService.submit(() -> {
    28.                 lockByKey.lock(key);
    29.                 if (executingKeySet.contains(key)) {
    30.                     throw new RuntimeException("存在正在执行的 key:" + key);
    31.                 }
    32.                 executingKeySet.add(key);
    34.                 try {
    35.                     System.out.println("index:" + finalI + "对 [" + key + "] 加锁 ->" + Thread.currentThread().getName());
    36.                     TimeUnit.SECONDS.sleep(1);
    37.                 } catch (InterruptedException e) {
    38.                     throw new RuntimeException(e);
    39.                 } finally {
    40.                     System.out.println("index:" + finalI + "释放 [" + key + "] ->" + Thread.currentThread().getName());
    41.                     lockByKey.unlock(key);
    42.                     executingKeySet.remove(key);
    43.                     countDownLatch.countDown();
    44.                 }
    45.             });
    46.         }
    47.         countDownLatch.await();
    48.     }
    49. }

    如果同一个 key 没释放能够再次进入，会抛出异常。
    也可以通过日志来观察执行情况：

    1. index:0对 [a] 加锁 ->pool-1-thread-1
    2. index:6对 [d] 加锁 ->pool-1-thread-7
    3. index:4对 [c] 加锁 ->pool-1-thread-5
    4. index:3对 [b] 加锁 ->pool-1-thread-4
    5. index:6释放 [d] ->pool-1-thread-7
    6. index:4释放 [c] ->pool-1-thread-5
    7. index:0释放 [a] ->pool-1-thread-1
    8. index:3释放 [b] ->pool-1-thread-4
    10. index:1对 [a] 加锁 ->pool-1-thread-2
    11. index:5对 [b] 加锁 ->pool-1-thread-6
    12. index:1释放 [a] ->pool-1-thread-2
    13. index:5释放 [b] ->pool-1-thread-6
    15. index:2对 [a] 加锁 ->pool-1-thread-3
    16. index:2释放 [a] ->pool-1-thread-3

    2.2、同一个 key 可以有 n个线程执行

    2.2.1 代码实现

    每个 key 对应一个 Semaphore ，让同一个 key 的线程使用 Semaphore 控制同时执行的线程数。

    1. import lombok.SneakyThrows;
    3. import java.util.Map;
    4. import java.util.concurrent.ConcurrentHashMap;
    5. import java.util.concurrent.Semaphore;
    7. public class SimultaneousEntriesLockByKey<T> implements LockByKey<T> {
    9.     private final Map<T, Semaphore> semaphores = new ConcurrentHashMap<>();
    11.     /**
    12.      * 最大线程
    13.      */
    14.     private int allowed_threads;
    16.     public SimultaneousEntriesLockByKey(int allowed_threads) {
    17.         this.allowed_threads = allowed_threads;
    18.     }
    20.     /**
    21.      * 加锁
    22.      */
    23.     @Override
    24.     public void lock(T key) {
    25.         Semaphore semaphore = semaphores.compute(key, (k, v) -> v == null ? new Semaphore(allowed_threads) : v);
    26.         semaphore.acquireUninterruptibly();
    27.     }
    30.     /**
    31.      * 解锁
    32.      */
    33.     @Override
    34.     public void unlock(T key) {
    35.         // 如果key为空，直接返回
    36.         if (key == null) {
    37.             throw new IllegalArgumentException("key 不能为空");
    38.         }
    40.         // 从Map中获取锁对象
    41.         Semaphore semaphore = semaphores.get(key);
    42.         if (semaphore == null) {
    43.             throw new IllegalArgumentException("key " + key + "尚未加锁");
    44.         }
    45.         semaphore.release();
    46.         if (semaphore.availablePermits() >= allowed_threads) {
    47.             semaphores.remove(key, semaphore);
    48.         }
    49.     }

    2.2.2 测试代码

    1. import com.google.common.collect.Lists;
    2. import org.junit.Test;
    4. import java.time.LocalDateTime;
    5. import java.util.Collections;
    6. import java.util.HashMap;
    7. import java.util.List;
    8. import java.util.Map;
    9. import java.util.concurrent.CountDownLatch;
    10. import java.util.concurrent.ExecutorService;
    11. import java.util.concurrent.Executors;
    12. import java.util.concurrent.TimeUnit;
    14. public class SimultaneousEntriesLockByKeyTest {
    16.     private final int maxThreadEachKey = 2;
    17.     private final LockByKey<String> lockByKey = new SimultaneousEntriesLockByKey<>(maxThreadEachKey);
    19.     private final CountDownLatch countDownLatch = new CountDownLatch(7);
    20.     private final ExecutorService executorService = Executors.newFixedThreadPool(10);
    22.     @Test
    23.     public void test() throws InterruptedException {
    24.         List<String> keys = Lists.newArrayList("a", "a", "a", "b", "c", "b", "d");
    25.         Map<String, Integer> executingKeyCount = Collections.synchronizedMap(new HashMap<>());
    27.         for (int i = 0; i < keys.size(); i++) {
    28.             String key = keys.get(i);
    29.             int finalI = i;
    30.             executorService.submit(() -> {
    31.                 lockByKey.lock(key);
    32.                 executingKeyCount.compute(key, (k, v) -> {
    33.                     if (v != null && v + 1 > maxThreadEachKey) {
    34.                         throw new RuntimeException("超过限制了");
    35.                     }
    36.                     return v == null ? 1 : v + 1;
    37.                 });
    38.                 try {
    39.                     System.out.println("time:" + LocalDateTime.now().toString() + " ,index:" + finalI + "对 [" + key + "] 加锁 ->" + Thread.currentThread().getName() + "count:" + executingKeyCount.get(key));
    40.                     TimeUnit.SECONDS.sleep(1);
    41.                 } catch (InterruptedException e) {
    42.                     throw new RuntimeException(e);
    43.                 } finally {
    44.                     System.out.println("time:" + LocalDateTime.now().toString() + " ,index:" + finalI + "释放 [" + key + "] ->" + Thread.currentThread().getName() + "count:" + (executingKeyCount.get(key) - 1));
    45.                     lockByKey.unlock(key);
    46.                     executingKeyCount.compute(key, (k, v) -> v - 1);
    47.                     countDownLatch.countDown();
    48.                 }
    49.             });
    50.         }
    51.         countDownLatch.await();
    52.     }
    53. }

    输出：

    time:2023-03-15T20:49:57.044195 ,index:6对 [d] 加锁 ->pool-1-thread-7count:1
    time:2023-03-15T20:49:57.058942 ,index:5对 [b] 加锁 ->pool-1-thread-6count:2
    time:2023-03-15T20:49:57.069789 ,index:1对 [a] 加锁 ->pool-1-thread-2count:2
    time:2023-03-15T20:49:57.042402 ,index:4对 [c] 加锁 ->pool-1-thread-5count:1
    time:2023-03-15T20:49:57.046866 ,index:0对 [a] 加锁 ->pool-1-thread-1count:2
    time:2023-03-15T20:49:57.042991 ,index:3对 [b] 加锁 ->pool-1-thread-4count:2
    time:2023-03-15T20:49:58.089557 ,index:0释放 [a] ->pool-1-thread-1count:1
    time:2023-03-15T20:49:58.082679 ,index:6释放 [d] ->pool-1-thread-7count:0
    time:2023-03-15T20:49:58.084579 ,index:4释放 [c] ->pool-1-thread-5count:0
    time:2023-03-15T20:49:58.083462 ,index:5释放 [b] ->pool-1-thread-6count:1
    time:2023-03-15T20:49:58.089576 ,index:3释放 [b] ->pool-1-thread-4count:1
    time:2023-03-15T20:49:58.085359 ,index:1释放 [a] ->pool-1-thread-2count:1
    time:2023-03-15T20:49:58.096912 ,index:2对 [a] 加锁 ->pool-1-thread-3count:1
    time:2023-03-15T20:49:59.099935 ,index:2释放 [a] ->pool-1-thread-3count:0

    以上就是Java根据某个key加锁怎么实现的详细内容，更多关于Java根据某个key加锁怎么实现的资料请关注九品源码其它相关文章！

    相关热词： Java根据某个加锁实现
    上一篇：讲一讲如何在一个页面中使用多个百度分享按钮，分享不同的文章
    下一篇：vue3怎么获取url地址参数

    文章分类

    IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

    最后更新

    热门排行

    网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

    版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

    Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1