In Bezug auf Notify()

Question

Ich ging durch Threads und ich lese, dass die notify() Methode verwendet wird, um ein Signal an einen und nur einen der Threads zu senden, die im Wartepool des gleichen Objekts warten. Die Methode notifyAll() funktioniert auf die gleiche Weise wie notify(), nur sendet sie das Signal an alle Threads, die auf Object warten.

Jetzt ist meine Abfrage, dass wenn ich sagen habe ich 5 Threads und ein Haupt-Thread, so zunächst der Haupt-Thread startet und dann fünf andere Threads starten. Jetzt möchte ich nur eine Benachrichtigung an den dritten Thread senden. Wie könnte es mit der Verwendung von möglich sein, da hier nur eine Benachrichtigung an den dritten Thread gesendet wird? Bitte beraten.

Answer 1

Wenn Sie möchten, dass ein bestimmter Thread benachrichtigt wird, lassen Sie ihn wait() für ein anderes Objekt verwenden, und rufen Sie notify() für dieses Objekt auf.

Answer 2

Die Klasse ReentrantLock bietet eine feinere Kontrolle als das Schlüsselwort synchronized, da mehrere Wartesets pro Objekt zulässig sind.

Sie können mehrere Conditions von einem mit ReentrantLock.newCondition() erhalten. Ein Thread kann dann Condition.await() aufrufen (ähnlich in Funktion zu Object.wait()) und wird blockieren, bis ein anderer Thread Condition.signal() aufruft (ähnlich in Funktion zu Object.notify()).

Der Unterschied ist, dass Sie mehrere Conditions für eine einzelne ReentrantLock erstellen können. So können Sie einen Condition für jeden Thread erstellen und signal() auf der Bedingung aufrufen, die der Thread entspricht, die Sie aufwachen wollten.

---

Hier ist ein einfacher Beispielcode, der das oben genannte demonstriert. Es erzeugt 5 Threads, die alle auf unterschiedliche Conditions derselben ReentrantLock warten. Der Haupt-Thread ruft dann signal() auf, um einen bestimmten der Threads aufzuwecken.

import java.util.concurrent.locks.Condition; 
import java.util.concurrent.locks.ReentrantLock; 

public class ReentranLockTest 
{ 
    public static void main(String[] args) 
    { 
     final ReentrantLock lock = new ReentrantLock(); 

     int numThreads = 5; 

     Condition[] conditions = new Condition[numThreads]; 

     // start five threads, storing their associated Conditions 
     for (int i = 0; i < numThreads; i++) 
     { 
      final int threadNumber = i; 

      System.out.printf("Started thread number %d%n", threadNumber); 

      // to create a Condition we must lock the associated ReentrantLock 
      lock.lock(); 
      try 
      { 
       final Condition condition = lock.newCondition(); 
       conditions[i] = condition; 

       // start the worker Thread 
       (new Thread() 
       { 
        @Override 
        public void run() 
        { 
         // wait on the Condition 
         // to do so we must be holding the 
         // associated ReentrantLock 
         lock.lock(); 
         try 
         { 
          condition.await(); 
         } 
         catch (InterruptedException e) 
         { 
          e.printStackTrace(); 
         } 
         finally 
         { 
          lock.unlock(); 
         } 

         // print something when signal() 
         // is called on our Condition 
         System.out.printf("Thread number %d woke up!%n", threadNumber); 
        } 
       }).start(); 
      } 
      finally 
      { 
       lock.unlock(); 
      } 
     } 

     // acquire the ReentrantLock and call 
     // Condition.signal() to wake up Thread number 3  
     lock.lock(); 
     try 
     { 
      System.out.printf("Waking up Thead number %d%n", 3); 

      conditions[3].signal(); 
     } 
     finally 
     { 
      lock.unlock(); 
     } 
    } 
} 

Dies sollte drucken folgendes:

Started Garnnummer 0

Started Garnnummer 1

Started Garnnummer 2

Started Garnnummer 3

Gestartet Thread-Nummer 4

Aufwachen Thead Nummer 3

Thema Nummer 3 aufgewacht!