Deadlock-Situation mit verschiedenen Aktionen (Methoden) auf dem gleichen Objekt erstellen?

Question

Ich habe den nächsten einfache Klasse Code erstellt (die nur für meine Frage Klärung ist):

public class StudioClass { 

synchronized void dancing(String name) { 
    System.out.println(name + " is dancing"); 
} 

synchronized void singing(String name) { 
    System.out.println(name + " is singing"); 
} 

public class StudentA extends Thread { 
    String name; 

    public StudentA(String name) { 
     this.name = name; 
    } 

    @Override 
    public void run() { 
     dancing(name); 
     try { 
      Thread.sleep(100); 
     } catch (InterruptedException e) { 
     } 
     singing(name); 
    } 
} 

public class StudentB extends Thread { 
    String name; 

    public StudentB(String name) { 
     this.name = name; 
    } 

    @Override 
    public void run() { 
     singing(name); 
     try { 
      Thread.sleep(100); 
     } catch (InterruptedException e) { 
     } 
     dancing(name); 
    } 
} 

In diesem Beispiel ist die Reihenfolge Aktionen von Schülern A sind: Tanz und dann und Schüler singen B sind: singen und als tanzen. Dieses Szenario ist eine klassische Situation für eine Deadlock.

Wie kann ich bewusst eine Deadlock Situation durch diese Aktionen erstellen? Die einfache Lösung (wie ich es verstehe) ist es, jede Aktion (Gesang & Tanzen) als verschiedene Objekte zu definieren, aber ich frage mich, gibt es andere Wege, sie als Methoden zu behalten?

Answer 1

Ich sehe keine potenziellen Deadlocks mit Ihrem Code. Ein Thread führt eine einzige synchronisierte Methode aus, und während dieser Ausführung sehe ich keine Bedingungen, die dazu führen, dass zwei Threads unbestimmt auf einander warten. Im schlimmsten Fall wartet ein Thread darauf, dass der andere Thread die Sperre für die Methode freigibt. Sie sollten sich ein komplexeres Szenario mit einem gemeinsamen Objekt zwischen Threads oder zwischen Abhängigkeiten zwischen Aktionen vorstellen.

Answer 2

Sie verwenden keine freigegebene Ressource. Ohne dass es keine Deadlocks gibt.

A_lock (n)
: Wenn es eine Situation wie A war, B erfordern sowohl eine Sperre auf gemeinsam genutzte Variablen s, t einen Tanz und Gesang und die Schlösser wurden auf die folgende Art und Weise (unter anderem) erworben durchzuführen A_lock (t)
Tanz
singen
A_release (t)
A_release (n)

B_lock (t)
B_lock (n)
Tanz
singen
B_release (n)
B_release (t)

Es gibt eine Chance von Deadlock, wenn ein akquiriert s und B für einander t und warten erwirbt für die Ewigkeit Sperren aufzuheben.