Domanda

Qualcuno può dare un semplice codice di esempio deadlock in C #? E informi il modo più semplice per trovare situazione di stallo in C # codice di esempio. (Può essere lo strumento che rileverà il dead lock nel codice di esempio dato.)

Nota: Ho VS 2008

Nessuna soluzione corretta

Altri suggerimenti

Un modo comune è se si hanno nidificato blocchi che non sono acquisiti nello stesso ordine. Filo 1 potrebbe acquisire serratura A e filo 2 potrebbe acquisire blocco B e avrebbero deadlock.

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

lock(a) {
   lock(b) {

   }
}

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

  }
}

modifica: ad esempio non-lock .. utilizzando waithandles. Supponiamo Socrate e Cartesio stanno avendo bistecche ed entrambi, essendo filosofi buone maniere, richiedono sia una forchetta e un coltello per mangiare. Tuttavia, hanno solo un set di posate, per cui è possibile per ogni utensile di afferrare uno e poi aspettare per sempre per l'altro di consegnare la loro utensile.

Vedere la pranzo Problema Filosofale

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

Questo è un tipico codice per creare una situazione di stallo in codice C #. Checkout Questo articolo di MSDN: http://msdn.microsoft.com/en-us/ magazine / 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();

    }
}

Per il codice di esempio situazione di stallo, provare a utilizzare lock(this) nella tua classe per simulare lo scenario di stallo. Acquista questo esempio .

A seguito di due articoli di lettura degni rileva la situazione di stallo in fase di esecuzione e discute i modi per evitarli.

  1. Deadlock monitorare da Stephen Toub.
  2. TimedLock Anche in questo caso da Ian Griffiths.

C'è un altro modo per raggiungere situazione di stallo in C #. Poiché NET numero 2.0 SP1 di thread nel pool sono limitati a 250 (da 25 nella versione precedente) per core.

Quindi, techically, è possibile avviare troppi compiti in piscina che attendere il completamento di un'altra operazione asincrona (che viene eseguito attraverso pool di thread). Pertanto, compito in piscina non sarà rilasciato e il compito asincrona non si avvia perché non ci sono thread disponibili.

Si possono trovare esempio e più precisa spiegazione qui: Programmazione del pool di thread. Deadlock

Per rispondere alla parte della tua domanda sul rilevamento stallo, io piuttosto dubbio che questo è in possibile generale. E 'simile in questione con il problema della terminazione, non è possibile calcolare in modo efficace la semantica. Un modo per superare questo è quello di utilizzare un cane da guardia che periodicamente il polling ogni thread se è ancora vivo e dare un certo timeout per rispondere, se 2 fili non rispondono, si può assumere o sono troppo occupati o sono scadenze bloccato.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top