那些遇到过的问题

如何通过密钥获取锁定

use*_*016 25 java algorithm synchronization locking

在不锁定整个集合的情况下,防止在键值集中并发更新一个记录的最佳方法是什么？从语义上讲,我正在寻找某种键的锁定(理想情况下,Java实现,但不一定):

interface LockByKey {
   void lock(String key); // acquire an exclusive lock for a key   
   void unlock(String key); // release lock for a key
}
Run Code Online (Sandbox Code Playgroud)

此锁用于同步对远程存储的访问,因此某些同步Java集合不是一个选项.

Lou*_*man 36

番石榴有这样的东西在13.0发布; 如果你愿意,你可以把它从HEAD中拿出来.

Striped<Lock>或多或少分配特定数量的锁,然后根据哈希代码将字符串分配给锁.API看起来或多或少像

Striped<Lock> locks = Striped.lock(stripes);
Lock l = locks.get(string);
l.lock();
try {
  // do stuff 
} finally {
  l.unlock();
}
Run Code Online (Sandbox Code Playgroud)

或多或少,可控制的条带数使您可以根据内存使用情况进行并发交易,因为为每个字符串键分配完整的锁可能会变得昂贵; 实质上,当你得到哈希冲突时,你只会得到锁争用,这是(可预见的)罕见的.

(披露:我向番石榴捐款.)

  • 如果您使用工厂方法生成弱锁,则会执行此操作. (3认同)
  • @Jose Martinez：不，它不清洁任何东西，它没有必要，它以不同的原理运行。以`Striped.lock(1024)`为例，它创建了简单的 Lock[1024] 数组，用 1024 个预生成的 Lock 对象急切地初始化；参见`Striped.CompactStriped`。您可以拥有具有数十亿个唯一 ID 的应用程序，但您的锁池始终保持在 1024 个相同的锁。`Striped` 以统计上非常低的概率运行 2 个或更多的 ID，生成相同的散列试图同时访问互斥锁。 (2认同)
  • @Espinosa，如果你调用 `Striped.lazyWeakLock` 而不是 `Striped.lock`，那么锁很弱。 (2认同)

Ali*_*aka 7

我编写了一个可以动态锁定任何键的类。它使用静态CuncurrentHashMap. 但如果不使用锁，则映射为空。当我们根据键创建新对象时，语法可能会令人困惑。它会清理 上的锁（如果未使用）unlock。可以保证DynamicKeyLock基于两个 equal/hascode 键创建的任何两个键都将相互锁定。

请参阅 Java 8、Java 6 的实现和一个小测试。

Java 8：

public class DynamicKeyLock<T> implements Lock
{
    private final static ConcurrentHashMap<Object, LockAndCounter> locksMap = new ConcurrentHashMap<>();

    private final T key;

    public DynamicKeyLock(T lockKey)
    {
        this.key = lockKey;
    }

    private static class LockAndCounter
    {
        private final Lock lock = new ReentrantLock();
        private final AtomicInteger counter = new AtomicInteger(0);
    }

    private LockAndCounter getLock()
    {
        return locksMap.compute(key, (key, lockAndCounterInner) ->
        {
            if (lockAndCounterInner == null) {
                lockAndCounterInner = new LockAndCounter();
            }
            lockAndCounterInner.counter.incrementAndGet();
            return lockAndCounterInner;
        });
    }

    private void cleanupLock(LockAndCounter lockAndCounterOuter)
    {
        if (lockAndCounterOuter.counter.decrementAndGet() == 0)
        {
            locksMap.compute(key, (key, lockAndCounterInner) ->
            {
                if (lockAndCounterInner == null || lockAndCounterInner.counter.get() == 0) {
                    return null;
                }
                return lockAndCounterInner;
            });
        }
    }

    @Override
    public void lock()
    {
        LockAndCounter lockAndCounter = getLock();

        lockAndCounter.lock.lock();
    }

    @Override
    public void unlock()
    {
        LockAndCounter lockAndCounter = locksMap.get(key);
        lockAndCounter.lock.unlock();

        cleanupLock(lockAndCounter);
    }


    @Override
    public void lockInterruptibly() throws InterruptedException
    {
        LockAndCounter lockAndCounter = getLock();

        try
        {
            lockAndCounter.lock.lockInterruptibly();
        }
        catch (InterruptedException e)
        {
            cleanupLock(lockAndCounter);
            throw e;
        }
    }

    @Override
    public boolean tryLock()
    {
        LockAndCounter lockAndCounter = getLock();

        boolean acquired = lockAndCounter.lock.tryLock();

        if (!acquired)
        {
            cleanupLock(lockAndCounter);
        }

        return acquired;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException
    {
        LockAndCounter lockAndCounter = getLock();

        boolean acquired;
        try
        {
            acquired = lockAndCounter.lock.tryLock(time, unit);
        }
        catch (InterruptedException e)
        {
            cleanupLock(lockAndCounter);
            throw e;
        }

        if (!acquired)
        {
            cleanupLock(lockAndCounter);
        }

        return acquired;
    }

    @Override
    public Condition newCondition()
    {
        LockAndCounter lockAndCounter = locksMap.get(key);

        return lockAndCounter.lock.newCondition();
    }
}
Run Code Online (Sandbox Code Playgroud)

Java 6：

public class DynamicKeyLock<T> implements Lock
{
    private final static ConcurrentHashMap<Object, LockAndCounter> locksMap = new ConcurrentHashMap<Object, LockAndCounter>();
    private final T key;

    public DynamicKeyLock(T lockKey) {
        this.key = lockKey;
    }

    private static class LockAndCounter {
        private final Lock lock = new ReentrantLock();
        private final AtomicInteger counter = new AtomicInteger(0);
    }

    private LockAndCounter getLock()
    {
        while (true) // Try to init lock
        {
            LockAndCounter lockAndCounter = locksMap.get(key);

            if (lockAndCounter == null)
            {
                LockAndCounter newLock = new LockAndCounter();
                lockAndCounter = locksMap.putIfAbsent(key, newLock);

                if (lockAndCounter == null)
                {
                    lockAndCounter = newLock;
                }
            }

            lockAndCounter.counter.incrementAndGet();

            synchronized (lockAndCounter)
            {
                LockAndCounter lastLockAndCounter = locksMap.get(key);
                if (lockAndCounter == lastLockAndCounter)
                {
                    return lockAndCounter;
                }
                // else some other thread beat us to it, thus try again.
            }
        }
    }

    private void cleanupLock(LockAndCounter lockAndCounter)
    {
        if (lockAndCounter.counter.decrementAndGet() == 0)
        {
            synchronized (lockAndCounter)
            {
                if (lockAndCounter.counter.get() == 0)
                {
                    locksMap.remove(key);
                }
            }
        }
    }

    @Override
    public void lock()
    {
        LockAndCounter lockAndCounter = getLock();

        lockAndCounter.lock.lock();
    }

    @Override
    public void unlock()
    {
        LockAndCounter lockAndCounter = locksMap.get(key);
        lockAndCounter.lock.unlock();

        cleanupLock(lockAndCounter);
    }


    @Override
    public void lockInterruptibly() throws InterruptedException
    {
        LockAndCounter lockAndCounter = getLock();

        try
        {
            lockAndCounter.lock.lockInterruptibly();
        }
        catch (InterruptedException e)
        {
            cleanupLock(lockAndCounter);
            throw e;
        }
    }

    @Override
    public boolean tryLock()
    {
        LockAndCounter lockAndCounter = getLock();

        boolean acquired = lockAndCounter.lock.tryLock();

        if (!acquired)
        {
            cleanupLock(lockAndCounter);
        }

        return acquired;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException
    {
        LockAndCounter lockAndCounter = getLock();

        boolean acquired;
        try
        {
            acquired = lockAndCounter.lock.tryLock(time, unit);
        }
        catch (InterruptedException e)
        {
            cleanupLock(lockAndCounter);
            throw e;
        }

        if (!acquired)
        {
            cleanupLock(lockAndCounter);
        }

        return acquired;
    }

    @Override
    public Condition newCondition()
    {
        LockAndCounter lockAndCounter = locksMap.get(key);

        return lockAndCounter.lock.newCondition();
    }
}
Run Code Online (Sandbox Code Playgroud)

测试：

public class DynamicKeyLockTest
{
    @Test
    public void testDifferentKeysDontLock() throws InterruptedException
    {
        DynamicKeyLock<Object> lock = new DynamicKeyLock<>(new Object());
        lock.lock();
        AtomicBoolean anotherThreadWasExecuted = new AtomicBoolean(false);
        try
        {
            new Thread(() ->
            {
                DynamicKeyLock<Object> anotherLock = new DynamicKeyLock<>(new Object());
                anotherLock.lock();
                try
                {
                    anotherThreadWasExecuted.set(true);
                }
                finally
                {
                    anotherLock.unlock();
                }
            }).start();
            Thread.sleep(100);
        }
        finally
        {
            Assert.assertTrue(anotherThreadWasExecuted.get());
            lock.unlock();
        }
    }

    @Test
    public void testSameKeysLock() throws InterruptedException
    {
        Object key = new Object();
        DynamicKeyLock<Object> lock = new DynamicKeyLock<>(key);
        lock.lock();
        AtomicBoolean anotherThreadWasExecuted = new AtomicBoolean(false);
        try
        {
            new Thread(() ->
            {
                DynamicKeyLock<Object> anotherLock = new DynamicKeyLock<>(key);
                anotherLock.lock();
                try
                {
                    anotherThreadWasExecuted.set(true);
                }
                finally
                {
                    anotherLock.unlock();
                }
            }).start();
            Thread.sleep(100);
        }
        finally
        {
            Assert.assertFalse(anotherThreadWasExecuted.get());
            lock.unlock();
        }
    }
}
Run Code Online (Sandbox Code Playgroud)

Ant*_*Fil 7 

private static final Set<String> lockedKeys = new HashSet<>();

private void lock(String key) throws InterruptedException {
    synchronized (lockedKeys) {
        while (!lockedKeys.add(key)) {
            lockedKeys.wait();
        }
    }
}

private void unlock(String key) {
    synchronized (lockedKeys) {
        lockedKeys.remove(key);
        lockedKeys.notifyAll();
    }
}

public void doSynchronously(String key) throws InterruptedException {
    try {
        lock(key);

        //Do what you need with your key.
        //For different keys this part is executed in parallel.
        //For equal keys this part is executed synchronously.

    } finally {
        unlock(key);
    }
}
Run Code Online (Sandbox Code Playgroud)

try-finally - 非常重要 - 即使您的操作抛出异常，您也必须保证在操作后解锁等待线程。

归档时间：

查看次数：

10986 次

最近记录：

6 年，7 月 前
简单的基于Java名称的锁？ 57
java同步基于参数 21
更多相关链接
相关归档
如何在Java中将日期增加一天？ 537
找到一个平面上的4个点是否形成一个矩形？ 52
字符串分析 33
Java阻塞问题:为什么JVM会在许多不同的类/方法中阻塞线程？ 17
k-means聚类可以进行分类吗？ 14
算法 - O(n)中二进制搜索树的每两个节点之间的距离之和？ 10
查找C++区间树算法实现 8
寻找关于特里的好介绍 6
Android 锁定设备通知没有响起 5
java中如何实现类级锁定？ 2
难疑归档
如何从异步调用返回响应？ 5208
如何检查数组是否包含JavaScript中的对象？ 3778
迭代对象属性 1904
如何在Vim中进行不区分大小写的搜索 1579
如何有效地计算JavaScript中对象的键/属性数？ 1452
.gitignore被Git忽略了 1407
<meta http-equiv ="X-UA-Compatible"content ="IE = edge">是做什么用的？ 1378
为特定提交生成git补丁 1144
按列名从pandas DataFrame中删除列 1136
AngularJS中指令范围内的'@'和'='有什么区别？ 1053