Java中有没有办法使用两个锁对象进行同步？

Question

我想知道Java中是否有一种方法可以使用两个锁对象进行同步。 我的意思不是锁定任一对象，而是仅锁定两者。

例如，如果我有 4 个线程：

• 线程 A 使用对象 1 和对象 2 请求锁
• 线程 B 使用对象 1 和对象 3 请求锁
• 线程 C 使用对象 4 和对象 2 请求锁
• 线程 D 使用对象 1 和对象 2 请求锁

在上述场景中，线程 A线程 D 将共享一个锁，但线程 B 和线程 C 将拥有自己的锁。即使它们与两个对象之一重叠，但只有在两个对象都重叠时才应用相同的锁。

所以我有一个由许多线程调用的方法，它将根据特定的数据库执行特定的活动类型。我有数据库和活动的标识符对象，并且我可以保证该操作将是线程安全的，只要它不是基于与另一个线程相同的数据库的相同活动。

我理想的代码看起来像这样：

public void doActivity(DatabaseIdentifier dbID, ActivityIdentifier actID) {    
    synchronized( dbID, actID ) { // <--- Not real Java
       // Do an action that can be guaranteed thread-safe per unique
       // combination of dbIT and actID, but needs to share a 
       // lock if they are both the same.
    }
}

我可以创建一个由DatabaseIdentifier和ActivityIdentifier键控的锁对象的散列图，但是当我需要在a中创建/访问这些锁时，我将遇到相同的同步问题。线程安全的方式。

现在我只是在 DatabaseIdentifier 上进行同步。对于一个 DBIdentifier 同时进行多个活动的可能性要小得多，因此我很少会过度锁定。 （但不能对相反的方向说同样的话。）

任何人都有一个好的方法来处理这个问题，而不涉及强制不必要的线程等待？

谢谢！

Answer 1

让每个DatabaseIdentifier保留一组锁定其拥有的ActivityIdentifier的锁，

以便您可以调用

public void doActivity(DatabaseIdentifier dbID, ActivityIdentifier actID) {    
    synchronized( dbID.getLock(actID) ) { 
       // Do an action that can be guaranteed thread-safe per unique
       // combination of dbIT and actID, but needs to share a 
       // lock if they are both the same.
    }
}

，然后您只需要在底层集合上有一个（短）锁（使用ConcurrentHashMap ）在 dbID 中

，换句话说，

ConcurrentHashMap<ActivityIdentifier ,Object> locks = new...
public Object getLock(ActivityIdentifier actID){
    Object res = locks.get(actID); //avoid unnecessary allocations of Object

    if(res==null) {
        Object newLock = new Object();
        res = locks.puIfAbsent(actID,newLock );
        return res!=null?res:newLock;
    } else return res;
}

这比锁定 dbID 上的完整操作更好（特别是当它是一个长操作时），但仍然比

响应有关 EnumMap 的评论的理想场景更新更糟糕

private final EnumMap<ActivityIdentifier ,Object> locks;

/**
  initializer ensuring all values are initialized 
*/
{
    EnumMap<ActivityIdentifier ,Object> tmp = new EnumMap<ActivityIdentifier ,Object>(ActivityIdentifier.class)
    for(ActivityIdentifier e;ActivityIdentifier.values()){
        tmp.put(e,new Object());
    }
    locks = Collections.unmodifiableMap(tmp);//read-only view ensures no modifications will happen after it is initialized making this thread-safe
}


public Object getLock(ActivityIdentifier actID){
    return locks.get(actID);
}

Answer 2

我认为你应该采用 hashmap 的方式，但将其封装在 flyweight 工厂中。即，您调用：

FlyweightAllObjectsLock lockObj = FlyweightAllObjectsLock.newInstance(dbID, actID);

然后锁定该对象。享元工厂可以在地图上获取读锁以查看密钥是否在那里，如果不在则只执行写锁。它应该减少并发因素。

您可能还想研究在该映射上使用弱引用，以避免内存被垃圾回收。

Answer 3

我想不出一种方法可以真正体现您锁定一对对象的想法。一些低级并发研究人员可能能够发明一个，但我怀疑我们是否有必要的原语在 Java 中实现它。

我认为使用这些对作为密钥来识别锁对象的想法是一个很好的想法。如果您想避免锁定，请安排查找以使其不执行任何操作。

我建议使用一个两级映射，模糊地类似于：

Map<DatabaseIdentifier, Map<ActivityIdentifier, Lock>> locks;

模糊地使用：

synchronized (locks.get(databaseIdentifier).get(activityIdentifier)) {
    performSpecificActivityOnDatabase();
}

如果您预先知道所有数据库和活动是什么，那么只需在应用程序启动时创建一个包含所有组合的完全正常的映射，然后将其完全用作多于。唯一的锁定是在锁定对象上，并且不存在争用。

如果您不知道数据库和活动是什么，或者有太多组合无法预先创建完整的地图，那么您将需要增量创建地图。这就是并发欢乐时光的开始。

最简单的解决方案是延迟创建内部映射和锁，并使用普通锁保护这些操作：

Map<ActivityIdentifier, Object> locksForDatabase;
synchronized (locks) {
    locksForDatabase = locks.get(databaseIdentifier);
    if (locksForDatabase == null) {
        locksForDatabase = new HashMap<ActivityIdentifier, Object>();
        locks.put(databaseIdentifier, locksForDatabase);
    }
}
Object lock;
synchronized (locksForDatabase) {
    lock = locksForDatabase.get(locksForDatabase);
    if (lock == null) {
        lock = new Object();
        locksForDatabase.put(locksForDatabase, lock);
    }
}
synchronized (lock) {
    performSpecificActivityOnDatabase();
}

正如您显然意识到的那样，这将导致过多的争用。我提到它只是为了教学的完整性。

您可以通过使外部映射并发来改进它：

ConcurrentMap<DatabaseIdentifier, Map<ActivityIdentifier, Object>> locks;

并且：

Map<ActivityIdentifier, Object> newHashMap = new HashMap<ActivityIdentifier, Object>();
Map<ActivityIdentifier, Object> locksForDatabase = locks.putIfAbsent(databaseIdentifier, newHashMap);
if (locksForDatabase == null) locksForDatabase = newHashMap;
Object lock;
synchronized (locksForDatabase) {
    lock = locksForDatabase.get(locksForDatabase);
    if (lock == null) {
        lock = new Object();
        locksForDatabase.put(locksForDatabase, lock);
    }
}
synchronized (lock) {
    performSpecificActivityOnDatabase();
}

在放置和获取期间，每个数据库映射上将存在唯一的锁争用，并且根据您的报告，不会有太多那。您可以将内部映射转换为 ConcurrentMap 来避免这种情况，但这听起来有些过头了。

然而，将会有源源不断的 HashMap 实例被创建并提供给 putIfAbsent，然后被丢弃。您可以通过双重检查锁定的后现代原子混合来避免这种情况；将前三行替换为：

Map<ActivityIdentifier, Object> locksForDatabase = locks.get(databaseIdentifier);
if (locksForDatabase == null) {
    Map<ActivityIdentifier, Object> newHashMap = new HashMap<ActivityIdentifier, Object>();
    locksForDatabase = locks.putIfAbsent(databaseIdentifier, newHashMap);
    if (locksForDatabase == null) locksForDatabase = newHashMap;
}

在每个数据库映射已经存在的常见情况下，这将执行单个并发 get。在不常见的情况下，它将执行额外但必要的 new HashMap() 和 putIfAbsent。在极少数情况下，它不会，但另一个线程也发现，其中一个线程将执行冗余的 new HashMap() 和 putIfAbsent。那应该不贵。

实际上，我认为这是一个糟糕的想法，您应该将两个标识符粘在一起以形成一个双倍大小的键，并使用它在单个 ConcurrentHashMap 中进行查找。可悲的是，我太懒了，也懒得删除上面的内容。将此建议视为阅读本文的特别奖励。

PS 当看到一个 Object 实例只用作锁时，我总是有点恼火。我建议将它们称为 LockGuffins。

Answer 4

你的哈希图建议是我过去所做的。我要做的唯一改变是使用 ConcurrentHashMap，以最大限度地减少同步。

另一个问题是，如果可能的键发生变化，如何清理地图。