如何安全地深度复制不规则的二维数组

Question

我在编写 Java 类时偶然发现了一个烦恼；我不知道如何使复制二维数组线程安全。这是该类的简单版本：

public class Frame {
  private boolean[][] content;

  public Frame(boolean [][] content) {
    boolean[][] threadSafeCopy = deepCopy(content);
    if (!(threadSafeCopy != null)) {
      throw new NullPointerException("content must not be null");
    }
    if (!(threadSafeCopy.length > 0)) {
      throw new IllegalArgumentException("content.length must be greater than 0");
    }
    if (!(threadSafeCopy[0] != null)) {
      throw new IllegalArgumentException("content[0] must not be null");
    }
    if (!(threadSafeCopy[0].length > 0)) {
      throw new IllegalArgumentException("content[0].length must be greater than 0");
    }
    for (int i = 1, count = threadSafeCopy.length; i < count; ++i) {
      if (!(threadSafeCopy[i].length == threadSafeCopy[0].length)) {
        throw new IllegalArgumentException
            (   "content[" + i + "].length [" + threadSafeCopy[i].length
              + "] must be equal to content[0].length [" + threadSafeCopy[0].length + "]"
            );
      }
    }
    this.content = threadSafeCopy;
  }

  private boolean[][] deepCopy(boolean[][] content) {
    boolean[][] result = null;
    if (content != null) {
      synchronized(content) { //do our best to make this as multi-threaded friendly as possible
        result = new boolean[content.length][];
        for (int i = 0, count = content.length; i < count; ++ i) {
          if (content[i] != null)
          {
            synchronized(content[i]) {
              result[i] = content[i].clone();
            }
          }
        }
      }
    }
    return result;
  }

  public boolean[][] getContent() {
    boolean[][] result = new boolean[this.content.length][]; //defensive copy
    for (int i = 0, count = result.length; i < count; ++i) {
      result[i] = this.content[i].clone(); //defensive copy
    }
    return result;
  }
}

然而，上述方法private boolean[][] deepCopy(boolean[][] content) 的实现实际上并不是线程安全的。在此方法尝试复制时，可能正在由另一个线程主动修改该数组。当然，我已经防范了最滥用的情况，在基本阵列上使用synchronized。但是，这不会导致二维数组实例的集合被锁定。并且可以在复制过程中对其进行修改。

是否有某种方法可以为每个基本数组 (content) 和子数组 (content[0], content[1], ..., content[content.length - 1]) 收集对象锁，这样我就可以调用类似synchronized(objectsToLockSimultaneouslyList) 的东西，它会同时按列表的顺序锁定所有对象。如果是这样，我可以线程安全地复制数组的内容。

如果不是，还有哪些其他类型的解决方案可用于“阻止对数组的所有修改”，而无需更改实例化 Frame 的类或更改 Frame 的构造函数，这样它就不会使用数组，而只需要实例不可变的集合（它本身就是另一个怪诞的兔子洞）。

感谢您在这方面的任何指导。

更新： 我想做的事情基本上是不可能的。而且我对通过同步锁定对象的理解也是错误的（t​​yvm glowcoder，Paulo 和 Brian）。我现在将尝试将 Frame 上的界面更改为使用List<List<Boolean>>，这肯定看起来效率要低得多。或者我可以使用Set<XyCoordinate>，其中 XyCoordinate 的存在意味着“真实”。再一次，这似乎非常低效，但线程安全。啊！

Answer 1

我认为最好的办法是将数组包装在一个对象中并提供对它的同步访问。然后你可以对访问器方法进行“关门”的深拷贝。

void deepCopy(boolean[][] orig) {
    synchronized(orig) {
        boolean[][] result = new boolean[orig.length][];
        deepCopy(orig,0);
        return result;        
    }
}

/**
 * recursive method to lock all rows in an array, and then copy
 * them in (backwards, by chance)
 */
void deepCopy(boolean[][] orig, int row) {
    if(row == orig.length) return; // end condition
    synchronized(orig[row]) { // lock the row first
        deepCopy(orig,row+1); // lock the next row
        content[row] = new boolean[orig[row].length];
        for(int i = 0; i < content[row].length; i++)
            content[row][i] = orig[row][i];
        // now, do row - 1
    }
}

Answer 2

您似乎对对象锁有一些误解。

某个对象上的synchronized 块（或方法）不避免对此对象进行任何修改。它只是避免了其他线程同时处于同一对象的同步块或方法中（同一对象的wait()中的除外）。

因此，为了在这里实现线程安全，您必须确保对数组的所有访问都在同一个锁对象上同步。

Answer 3

我建议您考虑使用 java.util.concurrent 包。它有很多有用的类可能会对你有所帮助。

对于您的具体示例，您可以编写一个简单的ThreadSafe2DArray 类：

public class ThreadSafe2DArray {
    private ReadWriteLock readWriteLock;
    private Lock readLock;
    private Lock writeLock;
    private boolean[][] data;

    public ThreadSafe2DArray(int rows, int cols) {
        this.data = new boolean[rows][cols];
        this.readWriteLock = new ReentrantReadWriteLock();
        this.readLock = readWriteLock.readLock();
        this.writeLock = readWriteLock.writeLock();
    }

    public boolean get(int row, int col) {
        try {
            readLock.lock();
            return data[row][col];
        }
        finally {
            readLock.unlock();
        }
    }

    public void set(int row, int col, boolean b) {
        try {
            writeLock.lock();
            data[row][col] = b;
        }
        finally {
            writeLock.unlock();
        }
    }

    public boolean[][] copyData() {
        try {
            readLock.lock();
            // Do the actual copy
            ...
        }
        finally {
            readLock.unlock();
        }
    }
}

如果您想允许客户端进行自己的锁定，例如，如果客户端可以读取或更新一个块中的大量条目，您还可以公开原始数据数组和读/写锁。

这种方法比使用原始 synchronized 块灵活得多，并且可能更快或更适合您的情况，尽管很大程度上取决于您在实践中期望的争用类型。这样做的额外好处是您不需要强制任何内容不可变。

从根本上说，如果两个线程要争夺资源，它们必须就某种锁定机制达成一致。如果填充数据数组的线程不能很好地运行，那么唯一的选择是拥有一个强制锁定的包装器。如果另一个线程表现良好，那么您还可以在两个线程中同步顶级数组对象，或者您可以使用暴露锁和数据方法，或者只使用上面介绍的类并调用@987654324 @ 在你的 Frame 类中。

这个答案比我预期的要长得多。希望这是有道理的。

编辑：请注意，将unlock 调用放在finally 块内很重要，以防意外RuntimeException（或Error）在try 内的某处抛出。在这种情况下，代码非常简单，因此可能有点矫枉过正，但如果这个安全网已经到位，它将使代码更易于维护。

EDIT2：我注意到您特别提到了一个不规则数组。为了简洁起见，我将示例保留为常规数组:)

Answer 4

我真的认为您没有掌握多线程的一些核心概念。

如果其他线程引用了您传递给Frame 构造函数的数组，那么您在Frame 中所做的任何操作 都可以帮助您。其他线程可以随意修改。