主页 / coding / 问题 / 79257890
Accepted
Bass
Asked: 2024-12-06 19:52:11 +0800 CST

管理一组唯一值的多个排他锁

  • 772

假设我有多个字符串值（动态生成）和一个线程池，并且我希望每个字符串值在任何时候都最多由一个线程独占。因此，例如，如果字符串“foo”在某个时间段被线程T1锁定，则等待处理“foo”（或任何其他等于“foo”的字符串Object.equals()）的所有其他线程都必须等到线程T1释放锁定。

所以我想实现以下接口：

interface Lock { 
    void lock(@NonNull String key); 

    void unlock(@NonNull String key); 
}

正如我所说的，如果密钥已被其他线程锁定，则进入该方法的任何线程都lock(String)应该等待（或可中断地等待，或超时等待）。

并且该unlock(String)方法应该有效地解锁密钥，在两种情况下抛出异常：

  1. 每当尝试解锁未锁定的钥匙时
  2. 每当尝试解锁由其他线程（不是当前线程）锁定的密钥时。

显然，在实现上述接口时，我必须将一个ReentrantLock实例与任何即将被锁定的键关联起来，并且在整个过程中它都保持锁定状态。

我该如何实现LockByKey接口？java.util.concurrent包中的哪些并发原语最适合此任务？

java

2 个回答

  1. Best Answer

    你需要这样的东西

    public class StringLockImpl implements StringLock {
    private final Map<String, LockObject> map = new HashMap<>();
    private final Lock lock = new ReentrantLock();

    @Override
    public void lock(String key) {
        acquire(key).lock();
    }

    @Override
    public void unlock(String key) {
        release(key).unlock();
    }

    private Lock acquire(String key) {
        lock.lock();
        try {
            LockObject lockObject = map.computeIfAbsent(key, ignore -> new LockObject());
            lockObject.inc();
            return lockObject.getLock();
        } finally {
            lock.unlock();
        }
    }

    private Lock release(String key) {
        lock.lock();
        try {
            LockObject lockObject = map.get(key);
            if (lockObject.dec()) {
                map.remove(key);
            }
            return lockObject.getLock();
        } finally {
            lock.unlock();
        }
    }

    private static class LockObject {
        private int counter;
        @Getter
        private final Lock lock = new ReentrantLock();

        public void inc() {
            counter++;
        }

        public boolean dec() {
            return --counter == 0;
        }
    }
}

    如果您搜索网络，您可能会找到现有的实现。

    • 0

  2. 假设ConcurrentHashMap.compute()是原子的，那么可以稍微重写接受的答案如下：

    public final class StringLockImpl {
    private final Map<String, LockObject> map = new ConcurrentHashMap<>();

    public void lock(final String key) {
        acquire(key).lock();
    }

    public void unlock(final String key) {
        release(key);
    }

    private Lock acquire(final String key) {
        final LockObject lockObject = map.compute(key, (k, v) -> Objects.requireNonNullElseGet(v, LockObject::new).inc());
        return lockObject.lock;
    }

    private void release(final String key) {
        map.compute(key, (k, v) -> {
            if (v == null) {
                throw new IllegalStateException("Not locked by any thread: " + k);
            }

            try {
                v.lock.unlock();
            } catch (final IllegalMonitorStateException imse) {
                throw new IllegalStateException("Thread [" + Thread.currentThread().getName() + "] not holding the lock: " + k, imse);
            }
            return v.dec() == 0 ? null : v;
        });
    }

    private static final class LockObject {
        private int counter = 0;
        private final Lock lock = new ReentrantLock();

        LockObject inc() {
            counter++;
            return this;
        }

        int dec() {
            final int threadCount = --counter;
            if (threadCount < 0) {
                throw new IllegalStateException("Thread count is negative: " + threadCount);
            }
            return threadCount;
        }
    }
}
    • 0

相关问题