Esempio di deadlock del thread in C#

Question

Qualcuno può dare un esempio di come il thread deadlock può essere causato nel linguaggio C#?

Answer 1

static object object1 = new object(); 
static object object2 = new object(); 

public static void ObliviousFunction() 
{ 
    lock (object1) 
    { 
     Thread.Sleep(1000); // Wait for the blind to lead 
     lock (object2) 
     { 
     } 
    } 
} 

public static void BlindFunction() 
{ 
    lock (object2) 
    { 
     Thread.Sleep(1000); // Wait for oblivion 
     lock (object1) 
     { 
     } 
    } 
} 

static void Main() 
{ 
    Thread thread1 = new Thread((ThreadStart)ObliviousFunction); 
    Thread therad2 = new Thread((ThreadStart)BlindFunction); 

    thread1.Start(); 
    thread2.Start(); 

    while (true) 
    { 
     // Stare at the two threads in deadlock. 
    } 
} 

Answer 2

Da Threading in C#

All'altra estremità della scala, contesti di sincronizzazione separati invitano deadlock. Ecco un esempio:

[Synchronization] 
public class Deadlock : ContextBoundObject { 
    public DeadLock Other; 
    public void Demo() { Thread.Sleep (1000); Other.Hello(); } 
    void Hello() { Console.WriteLine ("hello"); } 
} 
public class Test { 
    static void Main() { 
    Deadlock dead1 = new Deadlock(); 
    Deadlock dead2 = new Deadlock(); 
    dead1.Other = dead2; 
    dead2.Other = dead1; 
    new Thread (dead1.Demo).Start(); 
    dead2.Demo(); 
} 

Poiché ogni istanza del non ritorno è creato all'interno di prova - una classe non sincronizzato - ogni istanza volontà ottiene il proprio contesto di sincronizzazione , e, di conseguenza, il proprio lucchetto. Quando i due oggetti chiamano gli uni sugli altri, non ci vuole molto per la situazione di stallo che si verifichi (un secondo, per la precisione!) Il problema sarebbe particolarmente insidiosa se la situazione di stallo e di prova classi sono stati scritti da diversi team di programmazione . Potrebbe essere irragionevole aspettarsi che il responsabile della classe Test sia anche consapevole della loro trasgressione, sia lo che sa come risolvere la questione . Questo è in contrasto con i blocchi espliciti , dove i deadlock sono solitamente più ovvi.