0

我正在尝试完成以下任务：

  1. 从用户那里获得两个输入 (length和amountOfCycles)
  2. length创建一个包含线程数量的数组。每个包含value范围内的整数[1, 100]。
  3. 循环amountOfCycles + 1次数并在每次迭代时执行以下操作：
    1. 打印数组的值。
    2. 根据其（循环）邻居更新数组中的每个值：
      • 如果值小于两个邻居的值：将值增加 1
      • 如果该值大于两个邻居的值：将该值减 1
      • 如果当前值小于或等于一个邻居，并且大于或等于另一个邻居：保持该值不变

根据它们的邻居更新这些值是它成为多线程的原因。请注意，这只是练习多线程的东西。通过简单地一起删除线程并创建数组的副本（我已经做过） ，我可以轻松地完成上述操作。

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

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

这是基于这个 SO question and answer及其接受的答案。

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

它使用随机值多次打印数组amountOfCycles + 1，但不会在周期之间更改任何值。这是由于IllegalMonitorStateExceptions我得到的。可能是因为我需要一个synchronized(barrier){ ... }地方，因为barrier在课堂Main上而不是Cell？但是，将其添加到类的run-methodCell会导致程序不再打印任何内容，也不会终止..

在我上面的代码中，在一个在线编译器中查看当前（不正确的）结果。

我期望它做什么：

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

4

2 回答 2

2

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

第一期

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

这就是为什么你得到IllegalMonitorStateException

第 2 期

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

第 3 期

你可能不想打电话Object.wait但是CyclicBarrier.await()。因此，讨论所需的同步Object.wait()不是所需解决方案的一部分，我添加它只是为了澄清。

于 2019-05-02T16:49:04.467 回答
1

有几个问题。

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();
  }
}
于 2019-05-02T17:07:12.670 回答