Thread-Verklemmung

[Adriano10]

public class NameOutput extends Thread {

    private static int NUMBER_OF_THREAD = 11;
    private static int number = 0;
    private static Object lock = new Object();
    private static int next = 1;
    private int myNumber;

    public NameOutput() {
    }

    public void run() {
        while (true) {
            synchronized (lock) {
                number++;
                if (number == next) {
                    System.out.println(getName() + ": " + ": " + next + ": " + number);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    next = (next + 1) % NUMBER_OF_THREAD;
                    lock.notifyAll();
                } else {
                    try {
                        number= 0;
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        new NameOutput().start();
        new NameOutput().start();
        new NameOutput().start();
    }

ich möchte ein kleines Programm schreiben, so dass jeder Thread seinen Namen jeweils zehnmal hintereinander ausgibt, ohne dass ihm einer der anderen Threads dazwischenfunkt.

Irgendwo gibt es bei mir Deadlock, kann jemand mich bitte unterstützen?

Vielen Dank im Voraus

 

[Robert Zenz]

synchronized funktioniert anders als du denkst in diesem Kontext. Effektiv ist das betreten des synchronized-Blocks mit einem Thread eine Sperre fuer alle anderen. Also alle anderen Threads bleiben beim synchronized stehen und warten darauf dass die Sperre vom ersten Thread freigegeben wird.

Dieser erste Thread landet aber irgendwann beim lock.wait(), was bedeutet er wartet darauf dass ein anderer Thread das Signal gibt das es weiter geht. Aber kein anderer Thread kann dieses Signal geben weil alle beim synchronized stehen. Ohne jetzt grosz darueber nachgedacht zu haben, wahrscheinlich brauchst du das erste synchronized nicht.

 

[Jw456]

Jeder Thread ist immer berechtig auf die gemeinsamen Variablen zuzugreifen.
Mit der Variablen “number“ willst du das ja steuern . Also solltest du den Zugriff auf diese Variable Steuern.

 

[httpdigest]

Aber kein anderer Thread kann dieses Signal geben weil alle beim synchronized stehen.

Das ist nicht korrekt. Ein object.wait() löst den Lock desselben Objektes, sodass andere Threads den synchronized Bereich betreten können.
Tatsächlich kann man object.wait() nur aufrufen, wenn man vorher den Lock auf das Objekt hat.

 

[Robert Zenz]

Das ist nicht korrekt. Ein object.wait() löst den Lock desselben Objektes, sodass andere Threads den synchronized Bereich betreten können.
Tatsächlich kann man object.wait() nur aufrufen, wenn man vorher den Lock auf das Objekt hat.

Ohhh...das hatte ich dann uebersehen. Ich kenne es nur als Konstrukt wie du meinst, und dachte immer das waere eine Sondersache. Dann nehme ich das zurueck...

 

[Jw456]

@Deface3
bei deinem code bekomme ich das

scheint mir nicht das zu sein was der TE will.

Thread-1: : 1: 1
Thread-1: : 2: 2
Thread-1: : 3: 3
Thread-1: : 4: 4
Thread-2: : 5: 1
Thread-0: : 6: 1
Thread-0: : 7: 2
Thread-0: : 8: 3
Thread-0: : 9: 4
Thread-0: : 10: 5
Thread-0: : 11: 6
Thread-0: : 12: 7
Thread-0: : 13: 8
Thread-0: : 14: 9
Thread-0: : 15: 10
Thread-2: : 16: 2
Thread-2: : 17: 3
Thread-2: : 18: 4
Thread-1: : 19: 5
Thread-1: : 20: 6
Thread-2: : 21: 5
Thread-2: : 22: 6
Thread-2: : 23: 7
Thread-2: : 24: 8
Thread-1: : 25: 7
Thread-1: : 26: 8
Thread-1: : 27: 9
Thread-2: : 28: 9
Thread-2: : 29: 10
Thread-1: : 30: 10

 

[mihe7]

ich möchte ein kleines Programm schreiben, so dass jeder Thread seinen Namen jeweils zehnmal hintereinander ausgibt, ohne dass ihm einer der anderen Threads dazwischenfunkt.

public class Worker implements Runnable {
    private Object lock;
    public Worker(Object lock) { this.lock = lock; }

    public void run() {
        synchronized(lock) {
            zeige10MalMeinenNamen();
        }
    }

    private void zeige10MalMeinenNamen() {         
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

 

[Adriano10]

@Deface3
bei deinem code bekomme ich das

scheint mir nicht das zu sein was der TE will.

Thread-1: : 1: 1
Thread-1: : 2: 2
Thread-1: : 3: 3
Thread-1: : 4: 4
Thread-2: : 5: 1
Thread-0: : 6: 1
Thread-0: : 7: 2
Thread-0: : 8: 3
Thread-0: : 9: 4
Thread-0: : 10: 5
Thread-0: : 11: 6
Thread-0: : 12: 7
Thread-0: : 13: 8
Thread-0: : 14: 9
Thread-0: : 15: 10
Thread-2: : 16: 2
Thread-2: : 17: 3
Thread-2: : 18: 4
Thread-1: : 19: 5
Thread-1: : 20: 6
Thread-2: : 21: 5
Thread-2: : 22: 6
Thread-2: : 23: 7
Thread-2: : 24: 8
Thread-1: : 25: 7
Thread-1: : 26: 8
Thread-1: : 27: 9
Thread-2: : 28: 9
Thread-2: : 29: 10
Thread-1: : 30: 10

richtig, da funktioniert leider nicht.

 

[Adriano10]

public class Worker implements Runnable {
    private Object lock;
    public Worker(Object lock) { this.lock = lock; }

    public void run() {
        synchronized(lock) {
            zeige10MalMeinenNamen();
        }
    }

    private void zeige10MalMeinenNamen() {       
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

Dein Code funktioniert korrekt, ich hätte eine Frage zu "lock". Warum hast Du es in der Methode main initialisiert und dann an Constructor übergeben? Also warum funktioniert nicht, wenn man direkt im Constructor z.B " public Worker() {
lock = new Obect()
}
initialisiert?

Vielen Dank im Voraus

 

[mihe7]

Dein Code funktioniert korrekt, ich hätte eine Frage zu "lock". Warum hast Du es in der Methode main initialisiert und dann an Constructor übergeben?

Die lock-Variable existiert pro Instanz. Es muss aber sichergestellt sein, dass die Synchronisation in allen Worker-Instanzen über das selbe(!) Objekt stattfindet. Daher ist es korrekt, wenn ein lock-Objekt erzeugt wird, das allen Worker-Instanzen zur Synchronisation zur Verfügung gestellt wird. Das ist letztlich nur eine Alternative zur statischen lock-Variable, wie Du sie verwendet hast.

 

[Jw456]

Ich würde sagen damit es nur eine Instanz von dem Objekt gibt.