Java:在原语上同步?

前段时间我为自己发明了这样的东西。我称之为等价类锁,意思是,它锁定所有与给定事物相等的事物。你可以得到它 from my github ,并根据Apache2许可证使用它,如果您愿意的话,也可以直接阅读并忘记它!

你可以尝试使用可重入锁,这样你就有了 Map<Long,Lock> . 现在,在lock.release()之后,可以测试lock.hasQueuedThreads()。如果返回false,您可以将其从映射中删除。

你可以试试下面的小技巧

String str = UNIQUE_METHOD_PREFIX + Long.toString(id);
synchornized(str.intern()) { .. }

100%保证返回相同的实例。

这个 UNIQUE_METHOD_PREFIX ,可以是硬编码常数,或者可以使用以下方法获得:

StackTraceElement ste = Thread.currentThread().getStackTrace()[0];
String uniquePrefix = ste.getDeclaringClass() + ":" +ste.getMethodName();

这将保证锁定只发生在这个精确的方法上。这是为了避免死锁。

首先:

2. 不要长时间锁定,除非你在构建它们时很小心。由autoboxing或Long.valueOf()在特定范围内创建的长值在整个JVM中保证是相同的,这意味着其他线程可能会锁定在同一个确切的长对象上,并给您带来串扰。这可能是一个微妙的并发错误(类似于锁定内部字符串)。

ConcurrentHashMap 可以用来实现这一点,因为CHM在内部由段(子映射)组成,并且每个段有一个锁。这使您的并发性等于段数(默认为16,但可配置)。

对于划分ID空间和创建锁集,还有许多其他可能的解决方案,但您对清理和内存泄漏问题非常敏感,在维护并发性的同时处理这些问题是一项棘手的工作。您需要对每个锁使用某种引用,并小心地管理旧锁的逐出,以避免逐出正在被锁定的锁。如果你走这条路,使用 ReentrantLock 或 ReentrantReadWriteLock

还有一些关于这个的东西和一个StripedMap的例子 Java Concurrency in Practice

我想说你已经很快找到解决办法了。制造 LockManager doWork :

public void doWork(long id) {
    LockObject lock = lockManager.GetMonitor(id);
    try {
        synchronized(lock) {
            // ...
        }
    } finally {
        lock.Release();
    }
}

比如:

Map<Long,Object> myMap = new HashMap<Long,Object>();
Map<Long,Object> mySyncedMap=Collections.synchronizedMap(myMap);

用(同步的)地图试试看。

在这里,我会使用一个规范化映射,它将 long 输入并返回规范 Long 对象,然后可以使用该对象进行同步。我写过规范化地图的文章 here ; 简单地替换 String 通过 长的 (为了让你的生活更轻松,让它花点时间 作为参数)。

一旦有了规范化映射,就可以这样编写锁保护代码:

Long lockObject = canonMap.get(id);
synchronized (lockObject)
{
    // stuff
}

规范化映射将确保 lockObject 为相同的ID返回。当没有对的活动引用时 ,它们将有资格进行垃圾收集,因此您不会用不必要的对象填充内存。

您可以创建一个列表或一组活动ID并使用wait和notify:

List<Long> working;
public void doWork(long id) {
synchronized(working)
{
   while(working.contains(id))
   {
      working.wait();
   }
   working.add(id)//lock
}
//do something
synchronized(working)
{
    working.remove(id);//unlock
    working.notifyAll();
}
}

解决的问题:

• 无内存泄漏,因为“锁”(长)将在解锁时移除

存在的问题:

我可能会在游戏中迟到,但此解决方案不会泄漏任何内存,而且您不必记住执行任何锁释放:

Synchronizer<AccountId> synchronizer = new Synchronizer();

...

// first thread - acquires "lock" for accountId accAAA

synchronizer.synchronizeOn(accountId("accAAA"), () -> {
    long balance = loadBalance("accAAA")
    if (balance > 10_000) {
        decrementBalance("accAAA", 10_000)
    }
})

...

// second thread - is blocked while first thread runs (as it uses the same "lock" for accountId accAAA)

synchronizer.synchronizeOn(accountId("accAAA"), () -> {
    long balance = loadBalance("accAAA")
    if (balance > 2_000) {
        decrementBalance("accAAA", 2_000)
    }
})

...

// third thread - won't be blocked by previous threads (as it is for a different accountId)

synchronizer.synchronizeOn(accountId("accXYZ"), () -> {
    long balance = loadBalance("accXYZ")
    if (balance > 3_500) {
        decrementBalance("accXYZ", 3_500)
    }
})

要使用它,只需添加一个依赖项:

compile 'com.github.matejtymes:javafixes:1.3.0'