Warum notify() funktioniert nicht in der unteren Code?

Question

Ich möchte meine gerade ungerade Zahl in der Reihenfolge 1 2 3 4 5 6 drucken. Ich denke zuerst Anruf in Odd-Thread benachrichtigen sollte die even-Thread wait() zum Drucken der nächsten geraden Zahl entsperren, aber es ist nicht der Fall. Es wird nur "1" gedruckt

class T1 extends Thread { 
    private String[] s1; 
    private boolean flag; 

    public T1(String[] args, boolean flag) { 
     this.flag = flag; 
     this.s1 = args; 
    } 

    public synchronized void run() { 
     for (int i = 0; i < s1.length; i++) { 
      if(flag) 
      { 
       try { 
        wait(); 
       } catch (InterruptedException e) { 
        System.out.println("exception"); 
       } 
      } 
      System.out.println(s1[i]); 
      notify(); 
      flag = true; 
     } 
    } 
} 

public class TestThread { 
    public static void main(String[] args) { 
     String[] s1 = { "1", "3", "5" }; 
     String[] s2 = { "2", "4", "6" }; 

     Runnable odd = new T1(s1,false); 
     Runnable even = new T1(s2,true); 

     new Thread(even,"even-thread ").start(); 
     new Thread(odd,"odd-thread ").start(); 

    } 
} 

Answer 1

Ihre Threads melden sich selbst, anstatt den anderen Thread zu benachrichtigen.

Sie können dies beheben, indem Sie den anderen Thread nach der Synchronisierung auf seinem Monitor benachrichtigen. Es wäre jedoch besser, wait() und notify() auf einem gemeinsamen Object.

Answer 2

Wie andere darauf hinweisen, verwenden die zwei Threads unterschiedliche Monitore, sie sollten ein gemeinsames Objekt als Monitor verwenden.

Aber auch das Fixieren löst nicht alle Ihre Probleme. Wie es ist, sehe ich auch die Möglichkeit für ein verpasstes Signal. (Ein Thread kann notify aufrufen, wenn der andere nicht wartet).

Alles in allem betrachten Sie nicht einige der Richtlinien, die für Wait-Notify verwendet werden sollten.

Von Java Concurrency in Practice:

Wenn Bedingung wartet mit (Object.wait oder Condition.await):

• immer eine Bedingung Prädikats einige haben Test von Objektzustand, bevor Sie fortfahren halten müssen ;
• Testen Sie das Bedingungsprädikat immer vor dem Aufruf wait, und erneut nach der Rückkehr von wait;
• Rufen Sie immer wait in einer Schleife;
• Stellen Sie sicher, dass die Statusvariablen, aus denen das Prädikat der Bedingung besteht, von der Sperre geschützt werden, die der Bedingungswarteschlange zugeordnet ist.
• Halten Sie die Sperre, die mit der Bedingungswarteschlange verknüpft ist, wenn Sie wait, notify oder notifyAll aufrufen; und
• Lassen Sie die Sperre nicht los, nachdem Sie das Prädikat der Bedingung überprüft haben, aber bevor Sie darauf reagieren.

Answer 3

Sie können den Code wie folgt benötigen:

class MyThread extends Thread { 
    private Object object; 
    private String[] s1; 

    public MyThread(String[] args, Object object) { 
     this.object = object; 
     this.s1 = args; 
    } 

    public void run() { 
     synchronized (object) { 
      for (int i = 0; i < s1.length; i++) { 
       System.out.println(s1[i]); 
       object.notifyAll(); 
       if (i == s1.length - 1) return; 
       try { 
        object.wait(); 
       } catch (InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } 
     } 
    } 
} 

public class TestThread { 
    private static Object object = new Object(); 

    public static void main(String[] args) { 
     String[] s1 = { "1", "3", "5" }; 
     String[] s2 = { "2", "4", "6" }; 
     Thread odd = new MyThread(s1, object); 
     odd.start(); 
     try { 
      Thread.sleep(100); 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } 
     Thread even = new MyThread(s2, object); 
     even.start(); 
    } 
} 

der Ausgang ist:

1 
2 
3 
4 
5 
6