Java 根据某个 key 加锁的实现方式

public interface LockByKey { /** * 加锁 */ void lock(T key); /** * 解锁 */ void unlock(T key); }

import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.locks.ReentrantLock; public class DefaultLockByKeyImpl implements LockByKey { private final Map lockMap = new ConcurrentHashMap<>(); /** * 加锁 */ @Override public void lock(T key) { // 如果key为空，直接返回 if (key == null) { throw new IllegalArgumentException("key 不能为空"); } // 获取或创建一个ReentrantLock对象 ReentrantLock lock = lockMap.computeIfAbsent(key, k -> new ReentrantLock()); // 获取锁 lock.lock(); } /** * 解锁 */ @Override public void unlock(T key) { // 如果key为空，直接返回 if (key == null) { throw new IllegalArgumentException("key 不能为空"); } // 从Map中获取锁对象 ReentrantLock lock = lockMap.get(key); // 获取不到报错 if (lock == null) { throw new IllegalArgumentException("key " + key + "尚未加锁"); } // 其他线程非法持有不允许释放 if (!lock.isHeldByCurrentThread()) { throw new IllegalStateException("当前线程尚未持有，key:" + key + "的锁，不允许释放"); } lock.unlock(); } } 

import com.google.common.collect.Lists; import org.junit.Test; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class DefaultLockByKeyImplTest { private final LockByKey lockByKey = new DefaultLockByKeyImpl<>(); private final CountDownLatch countDownLatch = new CountDownLatch(7); private final ExecutorService executorService = Executors.newFixedThreadPool(10); @Test public void test() throws InterruptedException { List keys = Lists.newArrayList("a", "a", "a", "b", "c", "b", "d"); Set executingKeySet = new HashSet<>(); for (int i = 0; i  { lockByKey.lock(key); if (executingKeySet.contains(key)) { throw new RuntimeException("存在正在执行的 key:" + key); } executingKeySet.add(key); try { System.out.println("index:" + finalI + "对 [" + key + "] 加锁 ->" + Thread.currentThread().getName()); TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); } finally { System.out.println("index:" + finalI + "释放 [" + key + "] ->" + Thread.currentThread().getName()); lockByKey.unlock(key); executingKeySet.remove(key); countDownLatch.countDown(); } }); } countDownLatch.await(); } } 

index:0对 [a] 加锁 ->pool-1-thread-1 index:6对 [d] 加锁 ->pool-1-thread-7 index:4对 [c] 加锁 ->pool-1-thread-5 index:3对 [b] 加锁 ->pool-1-thread-4 index:6释放 [d] ->pool-1-thread-7 index:4释放 [c] ->pool-1-thread-5 index:0释放 [a] ->pool-1-thread-1 index:3释放 [b] ->pool-1-thread-4 index:1对 [a] 加锁 ->pool-1-thread-2 index:5对 [b] 加锁 ->pool-1-thread-6 index:1释放 [a] ->pool-1-thread-2 index:5释放 [b] ->pool-1-thread-6 index:2对 [a] 加锁 ->pool-1-thread-3 index:2释放 [a] ->pool-1-thread-3

import lombok.SneakyThrows; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Semaphore; public class SimultaneousEntriesLockByKey implements LockByKey { private final Map semaphores = new ConcurrentHashMap<>(); /** * 最大线程 */ private int allowed_threads; public SimultaneousEntriesLockByKey(int allowed_threads) { this.allowed_threads = allowed_threads; } /** * 加锁 */ @Override public void lock(T key) { Semaphore semaphore = semaphores.compute(key, (k, v) -> v == null ? new Semaphore(allowed_threads) : v); semaphore.acquireUninterruptibly(); } /** * 解锁 */ @Override public void unlock(T key) { // 如果key为空，直接返回 if (key == null) { throw new IllegalArgumentException("key 不能为空"); } // 从Map中获取锁对象 Semaphore semaphore = semaphores.get(key); if (semaphore == null) { throw new IllegalArgumentException("key " + key + "尚未加锁"); } semaphore.release(); if (semaphore.availablePermits() >= allowed_threads) { semaphores.remove(key, semaphore); } } 

import com.google.common.collect.Lists; import org.junit.Test; import java.time.LocalDateTime; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class SimultaneousEntriesLockByKeyTest { private final int maxThreadEachKey = 2; private final LockByKey lockByKey = new SimultaneousEntriesLockByKey<>(maxThreadEachKey); private final CountDownLatch countDownLatch = new CountDownLatch(7); private final ExecutorService executorService = Executors.newFixedThreadPool(10); @Test public void test() throws InterruptedException { List keys = Lists.newArrayList("a", "a", "a", "b", "c", "b", "d"); Map executingKeyCount = Collections.synchronizedMap(new HashMap<>()); for (int i = 0; i  { lockByKey.lock(key); executingKeyCount.compute(key, (k, v) -> { if (v != null && v + 1 > maxThreadEachKey) { throw new RuntimeException("超过限制了"); } return v == null ? 1 : v + 1; }); try { System.out.println("time:" + LocalDateTime.now().toString() + " ,index:" + finalI + "对 [" + key + "] 加锁 ->" + Thread.currentThread().getName() + "count:" + executingKeyCount.get(key)); TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); } finally { System.out.println("time:" + LocalDateTime.now().toString() + " ,index:" + finalI + "释放 [" + key + "] ->" + Thread.currentThread().getName() + "count:" + (executingKeyCount.get(key) - 1)); lockByKey.unlock(key); executingKeyCount.compute(key, (k, v) -> v - 1); countDownLatch.countDown(); } }); } countDownLatch.await(); } }