线程拒绝通知

Question

我正在通过线程，并且我读取了.. notify（）方法用于向同一对象的等待池中正在等待的线程中的一个且仅有一个线程发送信号。 notifyAll（）方法的工作方式与notify（）方法相同，只是它将信号发送给等待对象的所有线程。

现在我的问题是，如果我们说我有5个线程在等待并通过Notify（），我想发送通知给线程3，那么通知发送到线程3时应该有什么逻辑。 ！

Answer 1

你不能直接用wait和notify来做到这一点。你必须在某个地方设置一个标志，让线程中的代码检查它并返回到等待它是否是错误的线程，然后调用notifyAll。

请注意，如果您必须处理此问题，则可能表示您应该重构代码。如果你需要能够通知每个单独的线程，你应该让每个线程都等待一个不同的对象。

Answer 2

wait-notify是一个较低级别的机制来向其他线程指示事件（预期发生）。这是生产者/消费者机制的例子。

这不是线程彼此通信的机制。
如果你需要这样的东西，你看错了方向。

Answer 3

下面的代码启动五个线程，并设置第三个标志，告诉它它是唯一继续。然后通知所有等待同一个锁对象lock的线程（唤醒），但只有选中的一个继续。要小心，编写多线程应用程序并不容易（正确同步，处理虚假唤醒等）。您不应只需从组中唤醒一个特定线程，因为这指向不正确的问题分解。总之，在这里你去...

 

package test; 

public class Main { 

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

    private void start(int n) { 
    MyThread[] threads = new MyThread[n]; 
    for (int i = 0; i < n; i++) { 
     threads[i] = new MyThread(); 
     /* set the threads as daemon ones, so that JVM could exit while they are still running */ 
     threads[i].setDaemon(true); 
     threads[i].start(); 
    } 
    /* wait for the threads to start */ 
    try { 
     Thread.sleep(500); 
    } catch (InterruptedException ex) { 
     ex.printStackTrace(); 
    } 
    /* tell only the third thread that it is able to continue */ 
    threads[2].setCanContinue(true); 
    /* wake up all threads waiting on the 'lock', but only one of them is instructed to continue */ 
    synchronized (lock) { 
     lock.notifyAll(); 
    } 
    /* wait some time before exiting, thread two should be able to finish correctly, the others will be discarded with the end of the JVM */ 
    for (int i = 0; i < n; i++) { 
     try { 
     threads[i].join(500); 
     } catch (InterruptedException ex) { 
     ex.printStackTrace(); 
     } 
    } 
    System.out.println("Done!"); 
    } 

    /** synchronization object, i.e. a lock which makes sure that only one thread can get into "Critical Section" */ 
    private final Object lock = new Object(); 

    /** A simple thread to demonstrate the issue */ 
    private final class MyThread extends Thread { 
    private volatile boolean canContinue; 
    @Override 
    public void run() { 
     System.out.println(Thread.currentThread().getName() + " going to wait..."); 
     synchronized (lock) { 
     while (!canContinue) { 
      try { 
      lock.wait(1000); /* one second */ 
      } catch (InterruptedException ex) { 
      ex.printStackTrace(); 
      } 
     } 
     } 
     System.out.println(Thread.currentThread().getName() + " woken up!"); 
    } 
    public void setCanContinue(boolean canContinue) { 
     this.canContinue = canContinue; 
    } 
    }; 
} 
 

代码的输出是：

 
Thread-0 going to wait... 
Thread-2 going to wait... 
Thread-3 going to wait... 
Thread-1 going to wait... 
Thread-4 going to wait... 
Thread-2 woken up! 
Done! 

所以，你可以清楚地看到，只有第三个线程（从0开始索引）被唤醒。您必须更详细地研究Java同步和多线程，以了解代码的每一行（例如，here）。

我想帮助你更多，但我将不得不写几乎一本关于Java线程的书，这就是为什么我只是指出这个Java Tutorial on threads。你是对的，这个问题并不容易，特别是对初学者来说。所以我建议你阅读参考教程，然后你应该能够理解上面的大部分代码。有没有简单的方法或至少我不知道任何。