Synchronized Threads

[innoc]

Hallo erstmal,

ich versuche gerade Threads zu verstehen, und hänge jetzt an folgendem Problem fest:
Ich habe zwei Threads, die eine gemeinsame Variable vom Objekt-Typ verändern sollen. Thread 1 weist dem Objekt x den Wert 0 zu, Thread 2 dagegen den Wert 1. Über eine while-Schleife wird der Wert von x 20-Mal auf der Konsole ausgegeben (ist zwar nicht besonders spannend, aber ich brauche nur ein möglichst einfaches Beispiel). Der Programmcode den ich bisher zustande gebracht habe, arbeitet zuerst Thread 1, danach Thread 2 vollständig ab. Nun möchte ich, ohne die gesamte Programmstruktur komplett ändern zu müssen, eine alternierende Ausgabe von Nullen und Einsen für x erhalten. Hat jemand eine Idee, wie ich dazu das Programm verändern muss?
Also hier nun das Programm:

public class AlternatingSyncExample {
  static Object lockObject = new Object();
  
  static class Thread1 extends Thread {
    public void run() {
      synchronized (lockObject) {
        Object x = 0;
        for (int i = 0; i < 20; i++) {
          System.out.println(x);
          try {
            sleep(50);
          } catch (InterruptedException e) {
            System.out.println(e);
          }
        }  
      }
    }
  }

  static class Thread2 extends Thread {
    public void run() {
      synchronized (lockObject) {
        Object x = 1;
        for (int j = 0; j < 20; j++) {
          System.out.println(x);
          try {
            sleep(20);
          } catch (InterruptedException e) {
            System.out.println(e);
          }
        }
      }
    }
  }

  public static void main (String[] args) {
    Thread thr1 = new Thread1();
    thr1.start();
    Thread thr2 = new Thread2();
    thr2.start();
  }
}

 

[Zacherl]

Versuch mal das synchronized nicht um die ganze Schleife, sondern den Inhalt zu setzen - ich weiß nicht, obs dann schon alterniert (wird wohl eher ein bisschen ungeordnet sein), aber zumindest sollten die Threads dann nicht mehr komplett nacheinander ablaufen.

 

[SlaterB]

hier was zum Nachdenken,
wait/ notify findet man in Lehrbüchern

public class Test {
    public static void main(String[] args)  {
        new Thread12(1);
        new Thread12(0);
    }
}

class Thread12  extends Thread {
    static int[] lockObject = new int[1];
    private int my;

    public Thread12(int my) {
        this.my = my;
        start();
    }

    public void run() {
        synchronized (lockObject)    {
            for (int i = 0; i < 20; i++)      {
                while (lockObject[0] == my)   {
                    try   {
                        lockObject.wait();
                    }  catch (InterruptedException e)  {
                        e.printStackTrace();
                    }
                }
                System.out.println(my);
                lockObject[0] = my;
                lockObject.notify();
            }
        }
    }
}

 

[innoc]

Danke für die Antworten von Zacherl und SlaterB.
Mit notify() und wait() habe ich es auch schon probiert, aber ich habe die beiden Methoden nicht mit dem lockObjekt verknüpft. Wenn man die beiden Methoden für sich in den Thread-Klassen aufruft, werden sie an Thread1 und Thread2 gebunden, oder? Jedenfalls bekommt man dann keinen Fehler vom Compiler, sondern eine IllegalMonitorStateException geworfen. Stimmt das?

 

[SlaterB]

das stimmt