Partagez comment C# garantit la sécurité des threads en multi-threading

Programmation multithreadPar rapport à la programmation monothread, il existe un problème unique, qui est celui de la sécurité des threads. La soi-disant sécurité des threads signifie que si plusieurs threads s'exécutent en même temps dans le processus où se trouve votre code, ces threads peuvent exécuter ce code en même temps. Si les résultats de chaque exécution sont les mêmes que ceux des exécutions monothread et que les valeurs des autres variables sont également les mêmes que prévu. Les problèmes de sécurité des threads sont causés par des variables globales et des variables statiques .

Afin de garantir la sécurité de l'accès aux variables statiques dans des situations multithread, un mécanisme de verrouillage peut être utilisé pour le garantir, comme indiqué ci-dessous :

//Variables globales statiques qui doivent être verrouillé

 private static bool _isOK = false;
        //lock只能锁定一个引用类型变量
        private static object _lock = new object();
        static void MLock()
        {
            //多线程
            new System.Threading.Thread(Done).Start();
            new System.Threading.Thread(Done).Start();
            Console.ReadLine();
        }
        static void Done()
        {
            //lock只能锁定一个引用类型变量
            lock (_lock)
            {
                if (!_isOK)
                {
                    Console.WriteLine("OK");
                    _isOK = true;
                }
            }
        }

Il est à noter que Lock ne peut verrouiller qu'un objet de type référence. De plus, en plus du mécanisme de verrouillage, les versions supérieures de C# ont ajouté des méthodes async et wait pour garantir la sécurité des threads, comme indiqué ci-dessous :

public static class AsynAndAwait
{
        //step 1 
        private static int count = 0;
        //用async和await保证多线程下静态变量count安全
        public async static void M1()
        {
            //async and await将多个线程进行串行处理
            //等到await之后的语句执行完成后
            //才执行本线程的其他语句
            //step 2
            await Task.Run(new Action(M2));
            Console.WriteLine("Current Thread ID is {0}", System.Threading.Thread.CurrentThread.ManagedThreadId);
            //step 6
            count++;
            //step 7
            Console.WriteLine("M1 Step is {0}", count);
        }
        public static void M2()
        {
            Console.WriteLine("Current Thread ID is {0}", System.Threading.Thread.CurrentThread.ManagedThreadId);
            //step 3
            System.Threading.Thread.Sleep(3000);
            //step 4
            count++;
            //step 5
            Console.WriteLine("M2 Step is {0}", count);
        }
}

Dans le chronogramme, nous peut savoir, il y a deux threads qui interagissent, comme le montre la figure ci-dessous :

Après avoir utilisé async et wait, la séquence d'exécution du code ci-dessus est celle indiquée dans la figure ci-dessous :

S'il n'y a que des opérations de lecture pour les variables globales et les variables statiques dans chaque thread, mais aucune opération d'écriture, d'une manière générale, cette variable globale est thread-safe si ; plusieurs threads accèdent à une variable en même temps Lors de l'exécution d'opérations de lecture et d'écriture, la synchronisation des threads doit généralement être prise en compte, sinon la sécurité des threads peut être affectée

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!