仅使用通知方法恢复处于等待状态的所有线程

Question

我只想使用notify方法恢复所有进入等待状态的线程。我不想使用notifyAll（）恢复所有处于等待状态的线程。

public class MultithreadingTest{
    public static void main(String[] args) throws  Exception{
        SharedResource sr = new SharedResource();
        sr.isWaiting = true; // to make thread to go in waiting state
        Thread t1 = new Thread(sr);
        Thread t2 = new Thread(sr);
        Thread t3 = new Thread(sr);
        t1.start();
        t2.start();
        t3.start();
        sr.isWaiting = false; // to directly call the notify() based on condition
        Thread t6 = new Thread(sr);
        t6.start();
    }
}

class SharedResource implements Runnable{
    volatile boolean isWaiting;
    public void run(){
        System.out.println(Thread.currentThread().getName() + " enters with status " + this.isWaiting);
        synchronized (this){
            try {
                if(this.isWaiting) {
                    System.out.println(Thread.currentThread().getName() + " goes into waiting stage");
                    wait(); // Release the lock so other threads can acquire it
                    System.out.println(Thread.currentThread().getName() + " wakes up");
                } else {
                    System.out.println(Thread.currentThread().getName() + " calling the notify method");
                }
                notify(); // Notifying the random thread which is in waiting state to resume again
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

调用 wait（） 将释放内部锁，以便队列中的其他线程可以获取它。我希望最后一个线程直接调用 notify（），这将通知任何处于等待状态的线程再次恢复。等待线程唤醒并调用 notify（），这将再次恢复处于等待状态的线程。

Answer 1

在本例中，我们希望按以下顺序执行这些操作：

< li >生成线程T1、T2和T3，并让这三个线程在共享资源上Hibernate < li >更改易变标志，并生成T4 < li>T4进入临界区，唤醒一个Hibernate线程，然后退出 < li >收到通知后，每个线程只通知一次，然后退出

上面的代码几乎是正确的，但是由于< code>main方法是由“main”线程执行的，我们必须确保线程T1、T2和T3在生成线程T4之前处于等待状态。我们可以通过使用信号量来做到这一点。< code >主线程将阻塞< code>semaphore.acquire()调用，直到所有线程都处于正确的状态。

请注意，由于竞争，在上面的代码中，线程T1可能在标志设置为false后进入关键部分，因此我们将失去对操作顺序的控制。

请参阅下面的更新代码，它将输出类似

main thread starts
Thread-2 enters with status true
Thread-2 goes into waiting stage
Thread-1 enters with status true
Thread-1 goes into waiting stage
Thread-0 enters with status true
Thread-0 goes into waiting stage
Thread-3 enters with status false
Thread-3 calling the notify method
Thread-3 terminates
main thread terminates
Thread-2 wakes up
Thread-2 terminates
Thread-1 wakes up
Thread-1 terminates
Thread-0 wakes up
Thread-0 terminates

代码

package sample;

import java.util.concurrent.Semaphore;

public class MultithreadingTest {
  public static void main(String[] args) throws Exception {
    System.out.println("main thread starts");
    SharedResource sr = new SharedResource();
    // to make thread to go in waiting state
    sr.isWaiting = true;
    Thread t1 = new Thread(sr);
    Thread t2 = new Thread(sr);
    Thread t3 = new Thread(sr);
    t1.start();
    t2.start();
    t3.start();

    // let the main thread wait, until all 3 threads reach the checkpoint
    sr.numWaiting.acquire(3);
    sr.isWaiting = false; // to directly call the notify() based on condition
    Thread t6 = new Thread(sr);
    t6.start();
    System.out.println("main thread terminates");
  }
}

class SharedResource implements Runnable {
  // keep a count of how many threads entered the critical section
  // needed by the main thread to know when to start the "wake-up" thread
  Semaphore numWaiting = new Semaphore(0);
  volatile boolean isWaiting;

  public void run() {
    System.out.println(Thread.currentThread().getName() + " enters with status " + this.isWaiting);
    synchronized (this) {
      try {
        if (this.isWaiting) {
          System.out.println(Thread.currentThread().getName() + " goes into waiting stage");
          numWaiting.release(1);
          wait(); // Release the lock so other threads can acquire it
          System.out.println(Thread.currentThread().getName() + " wakes up");
        } else {
          System.out.println(Thread.currentThread().getName() + " calling the notify method");
        }
        notify(); // Notifying the random thread which is in waiting state to resume again
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName() + " terminates");
    }
  }
}