Ejemplo de interbloqueo de subprocesos en C#

Question

¿Alguien puede dar un ejemplo de cómo se puede causar el interbloqueo de subprocesos en el lenguaje 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

De Threading in C#

En el otro extremo de la escala, contextos de sincronización independientes invitan a callejones sin salida. He aquí un ejemplo:

[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(); 
} 

Debido a que cada instancia de interbloqueo se creado dentro de prueba - una clase de falta de sincronización - cada instancia voluntad obtiene su propio contexto de sincronización , y por lo tanto, su propio candado. Cuando los dos objetos llaman el uno del otro, no se necesita mucho tiempo para el estancamiento que ocurra (un segundo, para ser exactos!) El problema sería particularmente insidiosa si el punto muerto y la prueba clases fueron escritos por diferentes equipos de programación . Puede ser irrazonable esperar que los responsables de la clase de prueba sean conscientes de su transgresión, solo saben cómo resolver . Esto está en contraste con los bloqueos explícitos , donde los bloqueos son generalmente más obvios .