java - 使用来自同一类的两个线程(偶数和奇数)打印 1-1000

Question

所以我的任务是这样的:

1. 实例化同一类的两个对象

2. 提供构造函数参数，将一个线程指定为偶数，将另一个线程指定为奇数。

3. 依次启动两个线程

4. 奇数线程打印从 0 到 1000 的奇数

5. 偶数线程打印从 0 到 1000 的偶数

6. 但是它们应该同步，打印应该是 1 、 2 、 3 、 4 .....

7. 每行一个数字

但是我似乎无法正确释放锁。我尝试阅读这里的一些类似问题，但它们都使用多个类。我做错了什么？

编辑:我的主类正在这样做 -

NumberPrinter oddPrinter = new NumberPrinter("odd");
NumberPrinter evenPrinter = new NumberPrinter("even");

oddPrinter.start();
evenPrinter.start();

我的输出是 -奇数:1偶数:2...

public class NumberPrinter extends Thread {

private String name;
private int starterInt;
private boolean toggle;


public NumberPrinter(String name) {
    super.setName(name);
    this.name=name;

    if(name.equals("odd")) {
        starterInt=1;
        toggle = true;

    }
    else if(name.equals("even")) {
        starterInt=2;
        toggle = false;
    }
}

@Override
public synchronized void run() {

    int localInt = starterInt;
    boolean localToggle = toggle;

    if(name.equals("odd")) {


    while(localInt<1000) {

        while(localToggle == false)
        try {
            wait();
        }catch(InterruptedException e) {

              System.out.println("Main thread Interrupted");

        }
    System.out.println(name+": "+localInt);
    localInt +=2;
    localToggle = false;
    notify();

       }
    }

    else {

        while(localInt<1000) {


            while(localToggle == true)
                try {
                    wait();
                }catch(InterruptedException e) {

                      System.out.println("Main thread Interrupted");

                }
            System.out.println(name+": "+localInt);
            localInt +=2;
            localToggle = true;
            notify();
    }
}
}
}

Answer 1

这里的关键问题是两个线程无法相互协调。当您有一个局部变量(在本例中为 localToggle)时，方法之外的任何内容都无法观察或更改其值。

但是，如果您与两个线程共享一个对象，则其状态可能会发生变化，并且如果使用正确，这些状态更改将对两个线程都可见。

您将看到共享对象是 AtomicInteger 的示例，但是当您使用 synchronized、wait() 和 notify 时()，您不需要在原子包装器中内置额外的并发开销。

这是一个简单的概述:

class Main {
  public static main(String... args) {
    Main state = new Main();
    new Thread(new Counter(state, false)).start();
    new Thread(new Counter(state, true)).start();
  }
  int counter;
  private static class Counter implements Runnable {
    private final Main state;
    private final boolean even;
    Counter(Main state, boolean even) {
      this.state = state;
      this.even = even;
    }
    @Override
    public void run() {
      synchronized(state) {
        /* Here, use wait and notify to read and update state.counter 
         * appropriately according to the "even" flag.
         */
      }
    }
  }
}

我不清楚自己使用 wait() 和 notify() 是否是作业的一部分，但此大纲的替代方法是使用类似的内容BlockingQueue 在两个线程之间来回传递 token 。 (容易出错的)状态监控将内置到队列中，从而清理代码并减少出错的可能性。