根据邻居的值更新多线程单元。如何继续使用 CyclicBarrier？

Question

我正在努力完成以下任务：

从用户那里获取两个输入（length 和 amountOfCycles）
创建一个包含 length 个线程的数组。每个都包含 [1, 100].

value

循环 amountOfCycles + 1 次并在每次迭代中执行以下操作：
1. 打印数组的值。
2. 根据其（循环）邻居更新数组中的每个值：
  - 如果该值小于两个邻居的值：将值增加1
  - 如果该值大于两个邻居的值：将值减1
  - 如果当前值小于或等于一个邻居，并且大于或等于另一个邻居：保持值不变

根据邻居更新这些值是它成为多线程的原因。 请注意，这只是练习多线程的东西。通过简单地一起删除线程并创建数组的副本 (which I already did).

，我可以轻松地完成上述操作

到目前为止，这是我的代码：

import java.util.Arrays;
import java.util.Scanner;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Main{
  Cell[] cells;
  CyclicBarrier barrier;
  int length, amountOfCycles;

  Main(){
    Scanner stdin = new Scanner(System.in);
    length = stdin.nextInt();
    amountOfCycles = stdin.nextInt();
    barrier = new CyclicBarrier(length);
    cells = new Cell[length];
    for(int i=0; i<length; i++)
      cells[i] = new Cell(i);
  }

  public static void main(String[] args){
    Main program = new Main();
    program.start();
  }

  void start(){
    for(int i=0; i<length; i++)
      cells[i].run();

    for(int cycle = amountOfCycles; cycle >= 0; cycle--)
      System.out.println(Arrays.toString(cells));
  }

  class Cell implements Runnable{
    int value,
        index;

    Cell(int i){
      index = i;
      value = (int)(Math.random() * 100) + 1; // Random integer within the range [1, 100]
    }

    @Override
    public void run(){
      try{
        // Wait for the start of the cycle:
        barrier.wait();

        // Determine the increment for the value of this cell:
        // Get the values of the neighbors:
        int valueLeftNeighbor = cells[(length - index - 1) % length].value,
            valueRightNeighbor = cells[(index + 1) % length].value,
        // And create an increment-integer with default value 0:
            increment = 0;
        // If the current value is smaller than that of both neighbors:
        if(value < valueLeftNeighbor && value < valueRightNeighbor){
          // Increase the current value by 1
          increment = 1;
        }
        // If the current value is larger than that of both neighbors:
        if(value > valueLeftNeighbor && value > valueRightNeighbor){
          // Decrease the current value by 1
          increment = -1;
        }
        // If the current value is smaller than or equal to one neighbor,
        // and larger than or equal to the other neighbor:
        //  Leave the value the same (so increment stays 0)

        // Wait until every cell is done calculating its new value:
        barrier.await();

        // And then actually update the values of the cells
        value += increment;
      }catch(Exception ex){
        System.err.println("Exception occurred! " + ex);
        ex.printStackTrace();
      }
    }

    @Override
    public String toString(){
      return Integer.toString(value);
    }
  }
}

基于 and 。

我上面的代码目前做了什么：

它打印具有随机值的数组 amountOfCycles + 1 次，但在循环之间不更改任何值。这是由于 IllegalMonitorStateExceptions 我得到的。可能是因为我在某处需要一个 synchronized(barrier){ ... }，因为 barrier 在 class Main 而不是 Cell 中？将它添加到 Cell class 的 run 方法中会导致程序不再打印任何内容，也不会终止..

Here in my code above in an online compilers to see the current (incorrect) result.

我希望它做什么：

每次循环后修改数组中的值。

Answer 1

让我们回顾一下你的推理：

第 1 期

为了在任何对象上调用 wait()，当前线程必须拥有自己的监视器。您在没有任何同步（障碍）的情况下调用 barrier.wait()。

这就是你得到 IllegalMonitorStateException

的原因

第 2 期

添加同步部分会导致您的程序挂起，因为您没有创建任何线程。在 Runnable 上调用运行会在同一线程中同步执行它。没有其他线程可以调用 notify

第 3 期

您可能不想调用 Object.wait，而是调用 CyclicBarrier.await()。因此，Object.wait() 要求的同步讨论不是所需解决方案的一部分，我添加它只是为了澄清。

Answer 2

有一些问题。

1) 您没有创建线程。您可以像这样从 Runnable 创建线程：

Thread t = new Thread(runnable); //create thread
t.start(); //start the thread

更改您的代码：

for(int i=0; i<length; i++)
  cells[i].run();

像这样：

for (int i = 0; i < length; i++)
  new Thread(cells[i]).start();

2) 你不会在每个循环后打印数组你实际上没有实现任何循环来有一个循环。要在每个循环创建新的 Runnable 后打印数组，当所有线程到达循环屏障时将调用它，您可以直接将此 Runnable 设置为循环屏障

所以更改您的代码：

Scanner stdin = new Scanner(System.in);
length = stdin.nextInt();
amountOfCycles = stdin.nextInt();
barrier = new CyclicBarrier(length);
cells = new Cell[length];
for(int i=0; i<length; i++)
  cells[i] = new Cell(i);

像这样：

Scanner stdin = new Scanner(System.in);
length = stdin.nextInt();
amountOfCycles = stdin.nextInt();

cells = new Cell[length];
for (int i = 0; i < length; i++)
  cells[i] = new Cell(i);

barrier = new CyclicBarrier(length, () -> {
  System.out.println(Arrays.toString(cells)); //code that will run every time when all thread reach the cyclic barrier
});

3) 在线程中创建循环：

更改您的代码：

try{
  // Wait for the start of the cycle:
  barrier.wait(); //remove this, you never called notify so its useless

  //business logic omitted

  // Wait until every cell is done calculating its new value:
  barrier.await();

  // And then actually update the values of the cells
  value += increment;
}catch(Exception ex){
  System.err.println("Exception occurred! " + ex);
  ex.printStackTrace();
}

像这样：

int cycleCounter = 0;
while (cycleCounter < amountOfCycles) {
  cycleCounter++;
  try {
    //business logic omitted

    barrier.await();

    // And then actually update the values of the cells    
    value += increment;
  } catch (Exception ex) {
    System.err.println("Exception occurred! " + ex);
    ex.printStackTrace();
  }
}

根据邻居的值更新多线程单元。如何继续使用 CyclicBarrier？

Update multithreading cells based on neighbor's value. How to continue with CyclicBarrier?

java

multithreading

async-await

neighbours

cyclicbarrier