MultiThreading und Deadlock

Question

schlagen Sie mir Real-Time-Situationen, in denen ich mehrere Threads erstellen soll, und dann eine Deadlock-Situation vorstellen.Dies ist eine Art von Projekt !!! kann u ppl hilft die Anwendung mehr interessa mit einiger Echtzeit Situation

Answer 1

denken Philosophen, goldene Gabeln und eine große Schüssel Spaghetti

Answer 2

Sie verwenden, um den Erzeuger-Verbraucher-Algorithmus zu demonstrieren Multi-Threading zu machen.

Berichtgenerator Szenario wäre, Daten pro Bericht werden in eine Warteschlange für die weitere Verarbeitung von einem Dienst (der Hersteller) eingefügt. Der Berichtsprozessordienst (der Benutzer) nimmt Daten für einen Bericht aus der Warteschlange und verarbeitet sie jeweils einen Bericht. Es kann 5 verschiedene Instanzen von Report Processor Service geben. Alle verwenden Berichte aus einer einzigen Warteschlange (hier müssen Sie möglicherweise Sperren für die Warteschlange einführen usw.).

Answer 3

Dies wird eine Sackgasse führen:

public static void main(String[] args) 
{ 
    final Object object1 = new Object(); 
    final Object object2 = new Object(); 

    Thread thread1 = new Thread(
    new Runnable() 
    { 
     public void run() 
     {  
     try 
     {  
      //**** Lock on object1 first **** 
      synchronized(object1) 
      {  
      Thread.sleep(1000); 

      //**** Lock on object2 second **** 
      synchronized(object2) 
      { 
       System.out.println("Should never get here."); 
      } 
      } 
     } 
     catch (InterruptedException e) 
     {  
      System.out.println("Thread interupted."); 
     } 
     } 
    } 
); 

    Thread thread2 = new Thread(
    new Runnable() 
    { 
     public void run() 
     { 
     try 
     { 
      //**** Lock on object2 first **** 
      synchronized(object2) 
      {  
      Thread.sleep(1000); 

      //**** Lock on object1 second **** 
      synchronized(object1) 
      { 
       System.out.println("Should never get here."); 
      } 
      } 
     } 
     catch (InterruptedException e) 
     { 
      System.out.println("Thread interupted."); 
     } 
     } 
    } 
); 

    thread1.start(); 
    thread2.start(); 
} 

Grundsätzlich haben Sie zwei Threads bekam auf die gleichen Objekte für Schlösser im Wettbewerb. Thread 1 erhält die Sperre auf object1, während Thread 2 eine Sperre auf object2 erhält, jeder versucht dann, eine Sperre für das andere Objekt zu erhalten, und Sie haben einen Deadlock, weil ein anderer Thread bereits die Sperre hat.

Answer 4

Sie können auch mit einer festen Größe Thread-Pool Deadlock:

final ExecutorService exec = Executors.newFixedThreadPool(1); 
exec.submit(new Runnable() { 
    public void run() { 
     Future<?> f = exec.submit(new Runnable() { 
      public void run() { 
      } 
     }); 
     try { f.get(); } catch (Exception ex) { } 
    } 
});