7
votes

Verrouillage mort dans la multithreading

J'essayais de créer un exemple d'impasse. J'ai essayé le code suivant. Mais au lieu de créer une impasse, cela a fonctionné comme un charme. Aidez-moi à comprendre pourquoi cela n'a pas créé une impasse. Quel changement dans ce code créerait une impasse? XXX

c# multithreading

0 commentaires

4 Réponses :

3
votes

2 serrures, 2 filets.

Le fil A prend le verrouillage A, peut dormir puis essaie de prendre la serrure B. Le fil B prend le verrou B, dort puis essaie de prendre la serrure A, égale à une impasse.

[Le fil A doit dormir suffisamment longtemps pour que le fil b prend la serrure B avant de filer une tentative d'acquérir]

0 commentaires

0
votes

de Wikipedia -

Une impasse est une situation dans laquelle deux ou des actions plus concurrentes sont chacune En attendant que l'autre finisse, et Ainsi, ni jamais.
Vous ne remplissez pas cette exigence avec votre code ci-dessus - il n'y a jamais de point où le fil a et le thread B attendez-vous sur l'autre.

0 commentaires

11
votes

Comme tout le monde l'a dit, deux serrures acquises dans différentes commandes, de sorte que chacun attendait l'autre. J'ai également changé l'une des longueurs de sommeil pour assurer une probabilité élevée de l'impasse survenant.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ReferenceTypes
{
    class DeadLockExample
    {
        static int a;
        static int b;

        static object lockedObjA = new object();
        static object lockedObjB = new object();

        public static void Main(string[] args)
        {
            DeadLockExample.a = 20;
            DeadLockExample.b = 30;

            DeadLockExample d = new DeadLockExample();

            Thread tA = new Thread(new ThreadStart(d.MethodA));
            Thread tB = new Thread(new ThreadStart(d.MethodB));

            tA.Start();
            tB.Start();

            Console.ReadLine();
        }

        private void MethodA()
        {
            lock (DeadLockExample.lockedObjA)
            {
                Console.WriteLine(a);
                Thread.Sleep(1200);

                lock (DeadLockExample.lockedObjB) {
                    Console.WriteLine(b);
                }
            }
        }

        private void MethodB()
        {
            lock (DeadLockExample.lockedObjB)
            {
                Console.WriteLine(b);
                Thread.Sleep(1000);

                lock (DeadLockExample.lockedObjA) {
                    Console.WriteLine(a);
                }
            }
        }
     }
}

3 commentaires

Sauf que le fait que les dors ne garantissent pas l'impasse se produira (seule la synchronisation peut faire cela), c'est une bonne réponse :)

J'apprécie la réponse. Merci.

Ceci est l'exemple de blocage quintessentiel. La plupart des blocages en pratique ressemblent exactement à cela, sauf que les acquisitions de verrouillage sont typiquement d'au moins 8 rappels dans la trace de la pile après avoir été acheminées par des rappels des événements de minuterie sur les threads que vous n'aviez même pas réalisé.

1
votes

Voici de 3 façons différentes, vous pouvez causer une impasse. Cette liste n'est pas exhaustive.

Appelez une méthode de blocage à partir d'une section de verrouillage. Strong> p>

dans cet exemple de thread a acquiert une serrure puis appelle immédiatement une méthode de blocage pendant que Le même thread thread b tente d'acquérir la même serrure, mais se bloque car le filetage A attend que le fil b signaler l'événement avant de libérer la serrure. P>

public class Example
{
  private bool m_Signal = false;

  void ThreadA()
  {
    while (!m_Signal);
    m_Signal = false;
  }

  void ThreadB()
  {
    m_Signal = true;
    while (m_Signal);
  }
}

0 commentaires