同步块——锁定多个对象

Question

我正在建模一个游戏，其中多个玩家（线程）同时移动。 玩家当前所在位置的信息被存储两次：玩家有一个变量“hostField”，它引用棋盘上的一个字段，每个字段都有一个 ArrayList 存储当前位于该字段的玩家。

我对拥有冗余信息这一事实不太满意，但我发现如果不循环遍历大数据集，就无法避免这种情况。

然而，当一名玩家从一个场地移动到另一个场地时，我想确保（1）冗余信息保持链接（2）目前没有其他人操纵该场地。

因此我需要做类似的事情

synchronized(player, field) {
    // code
}

这是不可能的，对吧？

我应该怎么办？ :)

Answer 1

一个简单的解决方案是

synchronized(player) {
    synchronized(field) {
        // code
    }
}

但是，请确保您始终以相同的顺序锁定资源以避免死锁。

请注意，在实践中，瓶颈是字段，因此字段上的单个锁定（或专用的公共锁定对象，正如 @ripper234 正确指出的那样）可能就足够了（除非您同时以其他冲突的方式操纵玩家） 。

Answer 2

事实上，同步是针对代码的，而不是针对对象或数据的。在同步块中用作参数的对象引用代表锁。

因此，如果您有如下代码：

class Player {

  // Same instance shared for all players... Don't show how we get it now.
  // Use one dimensional board to simplify, doesn't matter here.
  private List<Player>[] fields = Board.getBoard(); 

  // Current position
  private int x; 

  public synchronized int getX() {
    return x;
  }

  public void setX(int x) {
    synchronized(this) { // Same as synchronized method
      fields[x].remove(this);
      this.x = x;
      field[y].add(this);
    }
  }
}

那么尽管位于同步块中，但对字段的访问不受保护，因为锁不同（它位于不同的实例上）。因此，您的棋盘的玩家列表可能会变得不一致并导致运行时异常。

相反，如果您编写以下代码，它将起作用，因为我们只有一个供所有玩家使用的共享锁：

class Player {

  // Same instance shared for all players... Don't show how we get it now.
  // Use one dimensional board to simplify, doesn't matter here.
  private List<Player>[] fields; 

  // Current position
  private int x;

  private static Object sharedLock = new Object(); // Any object's instance can be used as a lock.

  public int getX() {
    synchronized(sharedLock) {
      return x;
    }
  }

  public void setX(int x) {
    synchronized(sharedLock) {
      // Because of using a single shared lock,
      // several players can't access fields at the same time
      // and so can't create inconsistencies on fields.
      fields[x].remove(this); 
      this.x = x;
      field[y].add(this);
    }
  }
}

请务必仅使用一个锁来访问所有玩家，否则您的棋盘状态将不一致。

Answer 3

使用并发时，总是很难给出好的响应。这很大程度上取决于您真正在做什么以及真正重要的事情。

根据我的理解，玩家移动涉及：

1 更新玩家位置。

2 从上一个场中移除该球员。

3 将玩家添加到新字段。

想象一下您同时使用多个锁，但一次只获取一个：
- 另一个玩家可以完美地看到错误的时刻，基本上是在 1&2 或 2&3 之间。例如，某些玩家可能看起来已经从棋盘上消失了。

想象一下你像这样进行砖块锁定：

synchronized(player) {
  synchronized(previousField) {
    synchronized(nextField) {
      ...
    }
  }
}

问题是...它不起作用，请查看 2 个线程的执行顺序：

Thread1 :
Lock player1
Lock previousField
Thread2 :
Lock nextField and see that player1 is not in nextField.
Try to lock previousField and so way for Thread1 to release it.
Thread1 :
Lock nextField
Remove player1 from previous field and add it to next field.
Release all locks
Thread 2 : 
Aquire Lock on previous field and read it : 

线程 2 认为玩家 1 从整个棋盘上消失了。如果这样是您的应用程序的问题，您不能使用此解决方案。

临时锁定的另一个问题是：螺纹可能会被卡住。
想象一下 2 个玩家：他们在同一时间交换位置：

player1 aquire it's own position at the same time
player2 aquire it's own position at the same time
player1 try to acquire player2 position : wait for lock on player2 position.
player2 try to acquire player1 position : wait for lock on player1 position.

=>两名球员均被封锁。

我认为最好的解决方案是对游戏的整个状态仅使用一把锁。

当玩家想要读取状态时，它会锁定整个游戏状态（玩家和棋盘），并制作副本供自己使用。然后它就可以在没有任何锁的情况下进行处理。

当玩家想要写入状态时，它会锁定整个游戏状态，写入新状态，然后释放锁定。

=>锁定仅限于游戏状态的读/写操作。玩家可以在自己的副本上对棋盘状态进行“长时间”检查。

这可以防止任何不一致的状态，例如玩家在多个字段中或没有，但不会阻止该玩家可以使用“旧”状态。

它可能看起来很奇怪，但这是国际象棋游戏的典型情况。当您等待其他玩家移动时，您看到的棋盘与移动之前一样。您不知道其他玩家会采取什么行动，直到他最终移动为止，您都在“旧”状态下工作。

Answer 4

您不应该对您的建模感到难过 - 这只是一个双向可导航的关联。

如果您小心（如其他答案中所述）操作原子，例如在 Field 方法中，那很好。

public class Field {

  private Object lock = new Object();

  public removePlayer(Player p) {
    synchronized ( lock) {
      players.remove(p);
      p.setField(null);
    }
  }

  public addPlayer(Player p) {
    synchronized ( lock) {
      players.add(p);
      p.setField(this);
    }
  }
}

如果“Player.setField”受到保护就好了。

如果您需要“移动”语义的进一步原子性，请为板升一级。

Answer 5

阅读您的所有答案，我尝试应用以下设计：

1. 仅锁定玩家，而不是字段
2. 仅在同步方法/块中的同步方法/块中进行字段操作
3. 始终首先检查是否导致调用同步方法/块的前提条件 我认为情况仍然如此：

1.避免僵局，3.很重要，因为当玩家等待时事情可能会发生变化。

此外，我可以在不锁定字段的情况下进行，因为在我的游戏中，多个玩家可以留在一个字段中，只有某些线程必须进行交互。这种交互可以通过同步玩家来完成——不需要同步字段......

你觉得怎么样？