El estancamiento de la muestra en .net?

Question

¿Alguien puede dar un simple ejemplo de código Punto muerto en c #? Y por favor, decir la forma más sencilla de encontrar estancamiento en su C # código de muestra. (Puede ser la herramienta que detectará el bloqueo de la muerte en el código de ejemplo dado.)

NOTA: Tengo VS 2008

Answer 1

Una forma común es si usted tiene cerraduras anidados que no son adquiridos en el mismo orden. Enhebrar 1 podría adquirir bloqueo A y el hilo 2 podría adquirir bloqueo B y tendrían un punto muerto.

var a = new object();
var b = new object();

lock(a) {
   lock(b) {

   }
}

// other thread
lock (b) { 
  lock(a) {

  }
}

editar: ejemplo no bloqueo .. utilizando waithandles. Supongamos Sócrates y Descartes están teniendo los filetes y ambos, siendo filósofos buenos modales, requieren tanto un tenedor y un cuchillo para poder comer. Sin embargo, tienen un solo juego de cubiertos de plata, por lo que es posible para cada uno de agarrar utensilio y luego esperar para siempre a que el otro lado sobre su utensilio.

Vea la comedor filosofal Problema

WaitHandle fork = new AutoResetEvent(), knife = new AutoResetEvent();

while(Socrates.IsHungry) {
   fork.WaitOne();
   knife.WaitOne();
   Eat();
   fork.Set();
   knife.Set();
} 

// other thread
while(Descartes.IsHungry) {
   knife.WaitOne();
   fork.WaitOne();
   Eat();
   knife.Set();
   fork.Set();
} 

Answer 2

Este es un código típico para crear un punto muerto en el código C #. Pago y envío este artículo de MSDN: http://msdn.microsoft.com/en-us/ revista / cc188793.aspx

using System;

using System.Threading;


public class Simple {

    static object A = new object();

    static object B = new object();


    static void MethodA()
    {
        Console.WriteLine("Inside methodA");
        lock (A)
        {
            Console.WriteLine("MethodA: Inside LockA and Trying to enter LockB");
            Thread.Sleep(5000);           
            lock (B)
            {
                Console.WriteLine("MethodA: inside LockA and inside LockB");
                Thread.Sleep(5000);
            }
            Console.WriteLine("MethodA: inside LockA and outside LockB");
        }
        Console.WriteLine("MethodA: outside LockA and outside LockB");
    }

    static void MethodB()
    {
        Console.WriteLine("Inside methodB");
        lock (B)
        {
            Console.WriteLine("methodB: Inside LockB");
            Thread.Sleep(5000);
            lock (A)
            {
                Console.WriteLine("methodB: inside LockB and inside LockA");
                Thread.Sleep(5000);
            }
            Console.WriteLine("methodB: inside LockB and outside LockA");
        }
        Console.WriteLine("methodB: outside LockB and outside LockA");
    }

    public static void Main(String[] args)
    {

        Thread Thread1 = new Thread(MethodA);
        Thread Thread2 = new Thread(MethodB);
        Thread1.Start();
        Thread2.Start();
        Console.WriteLine("enter.....");
        Console.ReadLine();

    }
}

Answer 3

En el código de ejemplo estancamiento, intente utilizar lock(this) en su clase para simular el escenario de estancamiento. Pedido este ejemplo .

Después de dos artículos de lectura dignos detecta el marcador en tiempo de ejecución y analiza las formas de evitarlos.

1. punto muerto monitorear por Stephen Toub.
2. TimedLock vez más por Ian Griffiths.

Answer 4

Hay otra manera de lograr estancamiento en C #. Desde .NET número 2,0 SP1 de hilos en la piscina se limitan a 250 (de 25 en la versión anterior) por núcleo.

Así, techically, puede empezar a demasiadas tareas en la piscina que esperar que se complete para otra operación asíncrona (que se ejecuta a través del grupo de subprocesos). Por lo tanto, la tarea de la piscina no se dará a conocer y la tarea asíncrona no arranca porque no existe ningún hilo.

Puede encontrar más ejemplos y explicación precisa aquí: Programación del grupo de subprocesos. Callejones sin salida

Answer 5

Para responder a la parte de su pregunta sobre la detección de estancamiento, prefiero duda de que esto es posible en general. Es similar en cuestión con el problema de la parada, no se puede calcular de manera efectiva la semántica. Una forma de superar esto es utilizar un organismo de control que sondea periódicamente cada hilo si aún está vivo y le dan un cierto tiempo de espera de respuesta, si 2 hilos no responden, se puede asumir que son ya sea de ocupado o que han muerto, bloqueada.