Concurrent Cellular Automata Schauspieler bewegen

Question

Ich habe einen zweidimensionalen zellulären Automaten. In einigen Zellen kann ein Akteur (Agent) sein. Jeder Schauspieler ist ein roter Faden. Ich muss den Schauspieler basierend auf den 9 Zellen um die Schauspielerzelle herum bewegen. Ich möchte dies gleichzeitig tun, damit der Schauspieler in einer Zelle (4,5) die Nachbarzellen (3,4), (4,4), (5,4), (3,5), (5,5) verwenden kann. , (3,6), (4,6), (5,6) und keine anderen Akteure können diese Zellen benutzen. Wenn ein Schauspieler diese Zellen in seiner Nachbarschaft hat, muss er warten, bis sich der erste Schauspieler bewegt hat. Aber ich möchte es erlauben, den Schauspieler, der keine gemeinsame Nachbarschaft hat, gleichzeitig zu bewegen. So kann sich der Schauspieler in (4,5) gleichzeitig als Schauspieler in (10,5) bewegen, weil er keine gemeinsame Nachbarschaft hat.

Was ist die beste Lösung dafür? Kannst du etwas vorschlagen?

Answer 1

Die grobe Idee ist unten.

1. Erstellen Matrix von Zellobjekten, die für die Synchronisation
2. zuordnen Schauspieler zu den Zellen verwendet werden
3. Wenn Schauspieler zu einer anderen Zelle, um sie einen Monitor auf der Zelle erhalten müssen

Hinweis dass die Zelle, von der Actor sich zu bewegen beginnt, im unten stehenden Code nicht geschützt ist. Was würden Sie auch erwarten, wenn jede Zelle einen Actor hat?

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); 
         } 
        } 
       } 
      } 
     } 

    } 

}