0

我有一个二维元胞自动机。在某些细胞中可能有演员（代理人）。每个演员都是一个线程。我需要根据演员单元格周围的 9 个单元格移动演员。我想同时执行此操作，以便单元格 (4,5) 中的参与者可以使用相邻单元格 (3,4)、(4,4)、(5,4)、(3,5)、(5,5) , (3,6), (4,6), (5,6) 和其他任何参与者都不能使用这个单元格。如果某个演员在他的附近有这些牢房，他必须等到第一个演员搬家。但我想允许同时移动没有共同邻居的演员。所以 (4,5) 中的演员可以与 (10,5) 中的演员同时移动，因为他们没有共同的邻域。

什么是最好的解决方案？你能提出一些建议吗？

4

1 回答 1

1

粗略的想法如下。

  1. 创建 Cell 对象矩阵，用于同步
  2. 将 Actors 分配给单元格
  3. 每当 Actor 移动到另一个单元格时，它必须在该单元格上获得一个监视器

请注意，Actor 开始移动的单元格在下面的代码中不受保护。另外，如果填充的每个单元格都有一个 Actor，您会期望什么？

import java.util.ArrayList;
import java.util.List;

public class CellularAutomata {

    public static void main(String ... args) throws InterruptedException {
        final int rows = 5;
        final int cols = 5;
        Cell[][] matrix = new Cell[rows][cols];
        List<Actor> actors = new ArrayList<>();
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                matrix[i][j] = new Cell();
                //populate actors
                if ((i + j) % 2 == 0) {
                    Actor actor = new Actor(matrix, i, j);
                    actor.setName(String.format("Actor %d %d", i, j));
                    actors.add(actor);
                }
            }
        }
        for (Actor actor : actors) {
            actor.start();
        }
        for (Actor actor : actors) {
            actor.join();
        }
    }

    public static class Cell {}

    public static class Actor extends Thread {

        private final static int[][] circleMoves = {
                {-1, -1}, {-1, 0}, {-1, 1}
                , {0, 1}, {1, 1}, {1, 0}
                , {1, -1}, {0, -1}, {0, 0}
        };
        private final Cell[][] matrix;
        private final int row;
        private final int col;

        public Actor(Cell[][] matrix, int row, int col) {
            this.matrix = matrix;
            this.row = row;
            this.col = col;
        }

        @Override
        public void run() {
            for (int i = 0; i < circleMoves.length; i++) {
                int nextRow = row + circleMoves[i][0];
                int nextCol = col + circleMoves[i][1];
                if (nextRow >= 0 && nextRow < matrix.length
                        && nextCol >= 0 && nextCol < matrix[nextRow].length) {
                    Cell targetCell = matrix[nextRow][nextCol];
                    System.out.println(Thread.currentThread().getName() + " waiting for cell (" + nextRow + ";" + nextCol + ")");
                    synchronized (targetCell) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " moved to cell (" + nextRow + ";" + nextCol + ")");
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            throw new IllegalStateException(e);
                        }
                    }
                }
            }
        }

    }

}
于 2016-12-27T08:50:34.143 回答