Java notify() 在 wait() 之前运行？

Question

public class ThreadA {
    public static void main(String[] args){
        ThreadB b = new ThreadB();
        b.start();

        synchronized(b){
            try{
                System.out.println("Waiting for b to complete...");
                b.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }

            System.out.println("Total is: " + b.total);
        }
    }
}

class ThreadB extends Thread{
    int total;
    @Override
    public void run(){
        synchronized(this){
            for(int i=0; i<100 ; i++){
                total += i;
            }
            notify();
        }
    }
}

如上例，如果wait()块先进入，ThreadB中后续的notify()会告诉主线程继续。

但是我们不能保证wait()会在notify(之前执行），如果ThreadB先进入block呢？ Notify() 将在wait() 之前执行，所以wait() 将永远挂在那里（因为不再有notify() 告诉它继续）？处理这个问题的正确方法通常是什么？

Answer 1

您应该几乎总是将谓词与等待/通知一起使用。也就是说，你需要一个条件 您可以检查，例如变量变为真，队列变为空/满等。只是盲目地等待某人调用 .notify() 用例很少。

所以，以下是不行的，因为你说的原因，其他线程可以在 ThreadA 调用 .wait() 之前调用 .notify()

public class ThreadA {
    public static Object latch = new Object();
    public static void main(String[] args) {
        ThreadB b = new ThreadB();
        b.start();
        synchronized(latch ) {
            latch.wait(); //wait for B to finish a calculation
        }
        System.out.println("Total is: " + b.total);

    }
}

class ThreadB extends Thread {
    int total;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            total += i;
        }
       synchronized(ThreadA.latch) {
           ThreadA.latch.notify();
       }
    }
}

你需要做这样的事情：

 public class ThreadA {
    public static Object latch = new Object();
    public static boolean done = false;
    public static void main(String[] args) {
        ThreadB b = new ThreadB();
        b.start();
        synchronized(latch ) {
            while (!done) {   //wait for B to indicate it is finished.
                latch.wait(); 
            }
        }
        System.out.println("Total is: " + b.total);

    }
}

class ThreadB extends Thread {
    int total;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            total += i;
        }
       synchronized(ThreadA.latch) {
           ThreadA.done = true;         
           ThreadA.latch.notify();
       }
    }
}

请注意，在上面，done 变量受同步块保护，.wait() 将自动释放/重新获取该锁。所以没有竞争条件，如果 .notify() 在我们到达 .wait() 调用之前被调用，ThreadA 会发现因为 done 将是 true 并且根本不进入 .wait() 调用。

对于这个代码这样简单的情况，你可以等待线程B结束，可以用b.join();完成

Answer 2

您的问题的许多可能解决方案之一是：

public class ThreadA {
  public static final CyclicBarrier barrier = new CyclicBarrier(2);

  public static void main(String[] args) {
    ThreadB b = new ThreadB();
    b.start();
    try {
      barrier.await();
      System.out.println("Total is: " + b.total);
    } catch (InterruptedException | BrokenBarrierException ex) {
    }
  }
}

class ThreadB extends Thread {
    int total;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            total += i;
        }
        try {
          ThreadA.barrier.await();
        } catch (InterruptedException | BrokenBarrierException ex) {
        }
    }
}

Answer 3

我猜你想做这样的事情

public class ThreadA {
    public static void main(String[] args) {
        ThreadB b = new ThreadB();
        b.start();
        b.join(); // Wait for thread b to finish 

        System.out.println("Total is: " + b.total);

    }
}

您还应该让 ThreadB 只实现 Runnable 而不是扩展 Thread。

class ThreadB implements Runnable {
    int total;

    public void run() {
        for (int i = 0; i < 100; i++) {
            total += i;
        } 
    }
}

然后使用它

ThreadB tb = new ThreadB();
Thread b = new Thread(tb);