Threads aufeinander warten lassen?

[R0flC0pterpiL0t]

Ich habe eine Frage (warum schreibe ich denn sonst hier rein?)

Ich programmiere zurzeit eine Straßenkreuzung (diejenigen, die sich vielleicht daran erinnern, dass ich schon mal eine Frage hier reingestellt habe vor langer langer Zeit wegen der Programmierung einer gewissen Straßenkreuzung - ja, ich bin immer noch dran ) und wollte dort zwei Threads, die zwei Ampeln zeichnen, synchron schalten. Aber da die Synchronisation durch das Schlüsselwort synchronized irgendwie nur dazu führt, dass nur ein Thread auf ein Element zur gleichen Zeit zugreifen kann (so in etwa, sorry für meine Ausdrucksweise, hoffe, ihr wisst was ich meine), ist das irgendwie nicht das, was ich selbst mit "Synchronisation" meine.

Ich würde gerne die beiden Threads, die jeweils eine Ampel zeichnen (rufen repaint()-Methode einer erweiterten JPanel-Klasse auf) so miteinander synchronisieren, dass der Thread, der zuerst "Gelb" gezeichnet hat in der Ampel, auf den anderen Thread wartet, der noch mit "Gelb" beschäftigt ist. Es ist also ungewiss, welcher Thread auf wen warten muss. Die sollen halt aufeinander warten, bevor sie was neues zeichnen. Hoffe, das ist verständlich ausgedrückt.

Wenn ich beide einfach gleichzeitig malen lasse, komplett unabhängig voneinander, kommt es vor, dass ein Thread dem anderen kurzzeitig mal hinterherhinkt, und das ist dann schon nicht so praktisch in einer Straßenkreuzung, wenn die eine Ampel, die genau das gleiche wie die andere Ampel anzeigen soll, eine Sekunde länger Gelb zeigt als die andere. (ok, Sekunde ist übertrieben, aber man merkt es definitiv, dass die beiden Ampeln nicht "synchron" laufen, da sie ja voneinander nichts wissen).

Habe mir das irgendwie so vorgestellt, dass ich ein Integer x habe, der von einem Thread erhöht wird, wenn er fertig ist mit malen, und dann darauf wartet, bis dieser erneut erhöht wird durch den anderen Thread. Wenn x also zweimal erhöht wurde, sind beide fertig, und beide können weitermalen. Vielleicht könnte man das mit "synchronized" verbinden? Aber irgendwie schaffe ich es nicht, diese Idee in Code umzusetzen.

Habe eine Testklasse geschrieben, damit ich euch nicht den kompletten Code der Straßenkreuzung geben muss. Analog zu dem "warten, bis andere fertig mit zeichnen ist" kann man hier sagen, dass der Thread, der zuerst bis zur Fünf gezählt hat, soll warten, bis der andere Thread bei der Fünf angekommen ist, EGAL welcher Thread das ist. Aber wie kann man sowas implementieren?

Komme da gerade überhaupt nicht weiter :/

package threadtest;

public class ThreadTest extends Thread {

    public static void main(String[] args) {
        PrintDemo PD = new PrintDemo();
        ThreadDemo T = new ThreadDemo(PD);
        ThreadDemo T2 = new ThreadDemo(PD);
        T.start();
        T2.start();
    }
}

package threadtest;

public class ThreadDemo extends Thread{
    PrintDemo PD = new PrintDemo();
   
    ThreadDemo(PrintDemo pd) {
      PD = pd; 
    }
   
    @Override
    public void run() {
        System.out.println("Starting " + this.getName());
        PD.printCount(this.getName());
    }
}

package threadtest;

public class PrintDemo {
    public void printCount(String name) {
        for (int i = 0; i < 10; i++) {
            System.out.println("Counter --- " + i + " by: " + name);
        }       
    }
}

 

[Xyz1]

Wieso denn mit Threads? Das Neuzeichnen könnte ein einziger Thread erledigen.

Synchronized... brauchst du gar nicht! Es wird nicht auf ein gemeinsames Attribut zugegriffen.

Also wenn doch mit Threads:

public class Temp {

    public static void main(String[] args) {
        Thread[] threads = new Ampel[4];
        threads[0] = new Ampel("Ampel 1");
        threads[1] = new Ampel("Ampel 2");
        threads[2] = new Ampel("Ampel 3");
        threads[3] = new Ampel("Ampel 4");
        for (Thread thread : threads) {
            thread.start();
        }
    }

    private static class Ampel extends Thread {
        private String name;
        public Ampel(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            try {
                while(true) {
                System.out.println(name + " grün ...");
                Thread.sleep(5000);
                System.out.println(name + " gelb");
                Thread.sleep(1000);
                System.out.println(name + " rot!");
                Thread.sleep(5000);
                }
            } catch (InterruptedException ignore) {
            }
        }
    }
}

Ampel 1 grün ...
Ampel 2 grün ...
Ampel 4 grün ...
Ampel 3 grün ...
Ampel 1 gelb
Ampel 2 gelb
Ampel 4 gelb
Ampel 3 gelb
Ampel 1 rot!
Ampel 2 rot!
Ampel 4 rot!
Ampel 3 rot!
Ampel 1 grün ...
Ampel 2 grün ...
Ampel 4 grün ...
Ampel 3 grün ...
Ampel 1 gelb
Ampel 2 gelb
Ampel 4 gelb
Ampel 3 gelb
Ampel 1 rot!
Ampel 3 rot!
Ampel 4 rot!
Ampel 2 rot!
Ampel 4 grün ...
Ampel 2 grün ...
Ampel 3 grün ...
Ampel 1 grün ...

public class Temp {

    public static void main(String[] args) {
        Thread[] threads = new Ampel[4];
        threads[0] = new Ampel("Ampel 1");
        threads[1] = new Ampel("Ampel 2");
        threads[2] = new Ampel("Ampel 3");
        threads[3] = new Ampel("Ampel 4");
        for (Thread thread : threads) {
            thread.start();
        }
    }

    private static class Ampel extends Thread {
        private static Object o = new Object();
        private static Integer num = 1;
        private String name;
        public Ampel(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            try {
                while(true) {
                    synchronized(o) {
                        while (!Integer.valueOf(name.substring(6)).equals(num)) {
                            o.wait();
                        }
                        num=num%4+1;
                        o.notifyAll();
                    }
                System.out.println(name + " grün ...");
                Thread.sleep(5000);
                System.out.println(name + " gelb");
                Thread.sleep(1000);
                System.out.println(name + " rot!");
                Thread.sleep(5000);
                }
            } catch (InterruptedException ignore) {
            }
        }
    }
}

Das führt irgendwann dazu:
1.) zunächst schalten alle Ampeln gleichzeitig,
2.) dann schaltet erst Ampel 1, Ampel 2 usw. usf.

Edit: Integer und String sei in diesem Bsp. nicht optimal gewählt.

 

[R0flC0pterpiL0t]

Also die Idee einfach ein Objekt zu erstellen, nur um ein Objekt zu haben, auf das alle zugreifen und so man die Threads "synchronisieren" kann (in Anführungszeichen, weil ich ja nicht wirklich die implementiere Synchronisations-Methode wünsche, die andere Threads auf einen Thread warten lassen, sondern dass Threads AUFEINANDER warten) bringt mich schonmal weiter.

Aber in deinem Beispiel schalten ja, wie du selbst sagst, die einzelnen Ampel nacheinander. In echt, schalten ja zwei Ampeln, die sich gegenüber liegen, gleichzeitig. Also immer Paare sind miteinander "synchron".

Ich versuche mich mal weiter mit deinem Ansatz


edit: Und ich möchte das mit mehreren Threads haben, weil ich eine tatsächliche Nebenläufigkeit der Ampeln implementieren will. Ich weiß, dass wenn ich alles, also alle vier Ampeln, von einem Thread zeichnen lassen würde, alles wahrscheinlich so schnell gezeichnet wird, dass mir gar nicht auffällt, welche Ampel als erstes gezeichnet wurde. Aber das ist ja dann schon irgendwie ein Fake Will das halt so machen, wie ich es mir vorgestellt habe

Aber durch die mehreren Threads kommt halt das Problem auf, dass die nicht ständig zu 110% im selben Tempo laufen. Dann fällt halt schon auf, wenn ein Thread mal für paar Millisekunden hinterherhinkt, und so das andere Paar der Ampel mal für diese paar Millisekunden länger Gelb zeigt. Und das versuche ich zu lösen.

BTW: nur falls das jemand noch nicht verstanden hat: Die Ampeln werden wirklich in einem JFrame gezeichnet, also das ist keine Konsolenanwendung

 

[Joose]

Also die Idee einfach ein Objekt zu erstellen, nur um ein Objekt zu haben, auf das alle zugreifen und so man die Threads "synchronisieren" kann (in Anführungszeichen, weil ich ja nicht wirklich die implementiere Synchronisations-Methode wünsche, die andere Threads auf einen Thread warten lassen, sondern dass Threads AUFEINANDER warten) bringt mich schonmal weiter.

Aber in deinem Beispiel schalten ja, wie du selbst sagst, die einzelnen Ampel nacheinander. In echt, schalten ja zwei Ampeln, die sich gegenüber liegen, gleichzeitig. Also immer Paare sind miteinander "synchron".

Naja dann fasse doch die 2 gegenüberliegenden Ampel zusammen und lasse beiden im gleichen Thread schalten
Damit bleiben immer 2 Threads über, welche halbswegs synchronisiert werden sollten.

Aber durch die mehreren Threads kommt halt das Problem auf, dass die nicht ständig zu 110% im selben Tempo laufen. Dann fällt halt schon auf, wenn ein Thread mal für paar Millisekunden hinterherhinkt, und so das andere Paar der Ampel mal für diese paar Millisekunden länger Gelb zeigt. Und das versuche ich zu lösen.

Du musst halt mitmessen wie lange ein kompletter Durchlauf gedauert hat, wenn er zu kurz gedauert hat (die Grenze musst du wissen) dann lässt du den Thread einfach mal etwas länger schlafen.
Sprich nach jedem Durchlauf gleichst du die beiden Threads wieder aneinander an.

BTW: nur falls das jemand noch nicht verstanden hat: Die Ampeln werden wirklich in einem JFrame gezeichnet, also das ist keine Konsolenanwendung

Wenn man es genau nimmt sollte das egal sein. Logik und UI sollten getrennt voneinander funktionieren. Es macht dir das Arbeiten auch einfacher wenn du dich vorerst nur um korrekt laufende Threads kümmern musst und deren Synchronisation. Danach kann man immer noch ein hübsches GUI draufsetzen.

 

[R0flC0pterpiL0t]

Ich glaube, ich habe einen Ansatz, der auch zu funktionieren scheint nach ersten Tests, aber ich habe so meine Zweifel wie schön der ist, nachdem ich geschafft habe, dieses Problem, vor dem ich seit mehreren Tagen sitzt, in vllt 10 min zu lösen durch ein paar Zeilen

Wäre nett, wenn du oder jemand sich den anschauen könnten und mir seine Meinung dazu sagen könnte.

Thread-Klasse:

Spoiler: IntersectionDrawerThread.java

public class IntersectionDrawerThread extends Thread {
    IntersectionDrawer  trafficLight;
    /*int synch used to synchronize threads. if synch is 2 or bigger, both threads are
    finished drawing*/
    IntersectionSupervisor sup;
    int                 synch;
    //delaying threads
    int                 x;

    public void add(IntersectionDrawer trafficLight){
        this.trafficLight = trafficLight;
    }

    public void add(IntersectionSupervisor sup, int synch, int x) {
        this.sup = sup;
        this.synch = synch;
        this.x = x;
    }

    public void setSynch(int synch) {
        this.synch = synch;
    }

    @Override
    public void run() {
        try {
            sleep(x);
        }
        catch (Exception e) {
        }
        sup.setSynch(synch++);
        while (synch<2) {
            System.out.println(this.getName() + " is running!");
        }
    }       
}

Supervisor-Klasse (weiß über jeden "Ampel"-Thread Bescheid, und koordiniert bzw. synchronisiert diese):

Spoiler: IntersectionSupervisor.java

public class IntersectionSupervisor extends Thread {
    //IntersectionDrawer[]        trafficLight;
    IntersectionDrawerThread[]  thread;
    /*int synch used to synchronize threads. if synch is 2, both threads are
    finished drawing*/
    int                            synch = 0;

    /*public void add(IntersectionDrawer[] trafficLight) {
        this.trafficLight = trafficLight;
    }*/

    public void add(IntersectionDrawerThread[] thread) {
        this.thread = thread;
    }

    public void setSynch(int synch) {
        this.synch = synch;
    }


    @Override
    public void run() {
        System.out.println("Supervisor running!");
        thread[0].add(this,synch,100);
        thread[0].start();
        thread[1].add(this,synch,300);
        thread[1].start();
        while (true) {
            System.out.println("Supervisor syncing Threads!");
            thread[0].setSynch(synch);
            thread[1].setSynch(synch);
        }
    }
}

EDIT: Da war ich wohl zu voreilig. Das funktioniert doch (noch?) nicht.

 

[R0flC0pterpiL0t]

[...]
EDIT: Da war ich wohl zu voreilig. Das funktioniert doch (noch?) nicht.

Jetzt aber glaube ich wirklich, dass ich es raus habe

Spoiler: IntersectionSupervisor.java

public class IntersectionSupervisor extends Thread {
    //IntersectionDrawer[]        trafficLight;
    IntersectionDrawerThread[]  thread;
    /*int sync & sync2 used to synchronize threads. if sync2 is 2, both threads are
    finished drawing*/
    int                            sync = 0;
    int                            sync2;
 
    /*public void add(IntersectionDrawer[] trafficLight) {
        this.trafficLight = trafficLight;
    }*/
 
    public void add(IntersectionDrawerThread[] thread) {
        this.thread = thread;
    }
 
    public void setSync(int sync) {
        synchronized(this) {
            this.sync = sync;
            this.sync2 = sync+1;
            thread[0].setSync(sync2);
            thread[1].setSync(sync2);
        }
    }
 
 
    @Override
    public void run() { 
        System.out.println("Supervisor running!");
        thread[0].add(this,sync,50);
        thread[0].start();
        thread[1].add(this,sync,100);
        thread[1].start();     
        while (sync2<2) {
            //System.out.println("Supervisor syncing Threads!");
            System.out.println("Supervisor-sync = " + sync2);
        }
        System.out.println("Supervisor is exiting... Syncing successful!");
    }
}

Spoiler: IntersectionThreadDrawer.java

public class IntersectionDrawerThread extends Thread {
    IntersectionDrawer  trafficLight;
    /*int sync used to synchronize threads. if sync is 2 or bigger, both threads are
    finished drawing*/
    IntersectionSupervisor sup;
    int                 sync;
    //delaying threads
    int                 x;
 
    public void add(IntersectionDrawer trafficLight){
        this.trafficLight = trafficLight;
    }
 
    public void add(IntersectionSupervisor sup, int synch, int x) {
        this.sup = sup;
        this.sync = sync;
        this.x = x;
    }
 
    public void setSync(int sync) {
        synchronized(this) {
            this.sync = sync;
        }
    }
 
    @Override
    public void run() {
        System.out.println(this.getName() + " is running!");
        try {
            sleep(x);
        }
        catch (Exception e) {
        }
        sup.setSync(sync);
        while (sync<2) {
            System.out.println(this.getName() + " is still running!");
        }
        System.out.println(this.getName() + " is exiting!");
    }       
}

 

[Joose]

Jetzt aber glaube ich wirklich, dass ich es raus habe

Funktioniert es denn? Dann passt es ja schon mal.

Aber natürlich gibt es ein paar Verbesserungsvorschläge:

public class IntersectionSupervisor extends Thread {

Man sollte nur von einer Klasse ableiten, wenn man deren Funktionalität erweitern will.
Daher ist es bei Threading immer besser eine Klasse zu schreiben welche das Runnable Interface implementiert, und der Thread für diese Runnable aus.

        while (sync2<2) {
            //System.out.println("Supervisor syncing Threads!");
            System.out.println("Supervisor-sync = " + sync2);
}

Diese Schleife lastet unnötigerweise die CPU aus. Hier wird Unmengen an Output erzeugt.
(Nur als Hinweis: Mit dem ExecutorService vom JavaFramework gibt es eine gute Klasse um mehrere Threads parallel zu starten und diese zu "verwalten".)

        while (sync<2) {
            System.out.println(this.getName() + " is still running!");
        }

Auch diese Schleife erzeugt einfach nur unnötig viel Output und verbraucht CPU.
Hier sollte man ein "sleep" einbauen damit nur alle X millisekunden kontrolliert wird.

 

[R0flC0pterpiL0t]

Funktioniert es denn? Dann passt es ja schon mal.

Ja, also moment scheint alles zu funktionieren wie ich es erwartet habe. Aber habe es noch nicht mit dem JPanel versucht, sondern nur über die Konsolenausgabe. Werde ich wahrscheinlich morgen machen. War einfach zu aufgeregt, dass es geklappt hat, sodass ich das erstmal sacken lassen musste

Aber natürlich gibt es ein paar Verbesserungsvorschläge:

public class IntersectionSupervisor extends Thread {

Man sollte nur von einer Klasse ableiten, wenn man deren Funktionalität erweitern will.
Daher ist es bei Threading immer besser eine Klasse zu schreiben welche das Runnable Interface implementiert, und der Thread für diese Runnable aus.

Stimmt, von Runnable habe ich schon gelesen. Ergibt Sinn mit dem, dass man nur "extends Thread" benutzt, wenn man diese Klasse auch wirklich erweitern will (was das "extend" ja schon sagt... )

Auch diese Schleife erzeugt einfach nur unnötig viel Output und verbraucht CPU.
Hier sollte man ein "sleep" einbauen damit nur alle X millisekunden kontrolliert wird.

Ja, das habe ich mir schon gedacht, aber einen sleep einzubauen ist mir nicht eingefallen. Danke! Dann muss man auch nicht so viel scrollen im Output :3

(Nur als Hinweis: Mit dem ExecutorService vom JavaFramework gibt es eine gute Klasse um mehrere Threads parallel zu starten und diese zu "verwalten".)

Also hiervon habe ich noch nichts gehört. Werde ich mir mal anschauen. Bin ja gerade ziemlich im Multithreading-Bereich.


Vielen Dank für alles! Durch diesen kleinen Denkanstoß hab ich es wohl tatsächlich geschafft :3

 

[DrZoidberg]

Wieso verwendest du nicht java.util.concurrent.CyclicBarrier? Die Klasse ist genau für eine solche Situation gedacht.

 

[Xyz1]

Wieso verwendest du nicht java.util.concurrent.CyclicBarrier? Die Klasse ist genau für eine solche Situation gedacht.

Weil er das straightforward selbst programmieren sollte, und zwar nach meiner Vorgabe, s. d. immer zwei Ampeln gleichzeitig schalten können, und nach Rot auch 1-2 Sek. gewartet werden kann bis Grün.

 

[Xyz1]

falscher Thread