Comment travailler avec des threads en C #

Un thread est la plus petite unité d'exécution d'un processus. Le multithreading est la possibilité d'avoir plusieurs threads en mémoire à un moment donné et de basculer entre eux pour gérer plusieurs opérations en même temps. Le .Net Framework de Microsoft offre un excellent support pour travailler avec les threads.

Programmation des threads en C #

Pour travailler avec des threads, vous devez inclure l'espace de noms System.Threading dans votre application. Pour créer un nouveau thread, vous devez tirer parti du délégué ThreadStart et transmettre la référence à une méthode qui doit s'exécuter sur le thread. Notez qu'un délégué est un pointeur de fonction de type sécurisé. L'extrait de code suivant montre comment créer un nouvel objet de thread à l'aide de ce délégué.

 Thread t = nouveau Thread (nouveau ThreadStart (MyThreadMethod)); 

Pour démarrer le thread nouvellement créé, vous devez appeler la méthode Start sur l'objet thread que vous avez créé. La liste de codes suivante illustre cela. Notez que la méthode de thread MyThreadMethod s'exécute sur le nouveau thread (appelé thread de travail) qui a été créé.

 static void Main ()

        {

            Thread t = nouveau Thread (nouveau ThreadStart (MyThreadMethod));

            t.Start ();           

            Console.Read ();

        }

        static void MyThreadMethod ()

        {

            Console.WriteLine («Hello World!»);

        }

Afficher les états des threads en C #

Un thread en mémoire peut être dans différents états: Aborted, Background, Running, Stopped, Suspended, Unstarted, etc. Les états des threads sont définis dans l'énumération ThreadState disponible dans l'espace de noms System.Threading. Sauf si la méthode Start est appelée sur un thread, le thread est à l'état Unstarted. Lorsque la méthode Start est appelée sur l'instance de thread, l'état du thread passe de Unstarted à Running.

L'extrait de code suivant montre comment vous pouvez afficher l'état d'un thread dans la console.

 Thread t = nouveau Thread (nouveau ThreadStart (MyThreadMethod));

t.Start ();

Console.WriteLine («L'état du thread est:« + t.ThreadState.ToString ());

Contrôler les threads de premier plan et d'arrière-plan en C #

Les threads peuvent s'exécuter au premier plan ou en arrière-plan. Les threads que vous créez explicitement sont des threads de premier plan. L'une des principales différences entre un thread de premier plan et un thread d'arrière-plan est que votre application ne vit que tant qu'un ou plusieurs threads de premier plan sont en cours d'exécution. En substance, les threads de premier plan empêchent l'application de se terminer. En revanche, les threads d'arrière-plan ne maintiennent pas l'environnement Common Language Runtime en vie.

Vous pouvez définir l'état d'arrière-plan d'un thread à l'aide de la propriété IsBackground. Voici un exemple de code qui montre comment cela peut être réalisé.

 static void Main ()

        {

            Thread t = nouveau Thread (nouveau ThreadStart (MyThreadMethod));

            t.Start ();

            t.IsBackground = vrai;

            Console.WriteLine («L'état d'arrière-plan du thread est:« + t.IsBackground.ToString ());

            Console.Read ();

        }

Vous pouvez suspendre ou reprendre un thread en appelant les méthodes Suspend () et Resume () sur l'objet thread. Notez que vous ne pouvez reprendre un thread que vous avez précédemment suspendu en faisant un appel à la méthode Suspend ().

 Thread t = nouveau Thread (nouveau ThreadStart (MyThreadMethod));

t.Start ();

t.Suspend (); // Suspend le thread nouvellement créé

t.Resume (); // Reprend le thread suspendu

Cependant, il convient de noter que les méthodes Thread.Suspend () et Thread.Resume () sont obsolètes. Vous devez plutôt utiliser les méthodes AutoResetEvent et EventWaitHandle pour synchroniser les activités impliquant des threads.

Définir la priorité des threads en C #

Vous pouvez contrôler la priorité d'un thread pour déterminer la part relative du temps processeur qu'un thread obtiendra par rapport aux autres threads résidant dans la mémoire. La priorité de thread est définie dans l'énumération ThreadPriority. Les valeurs possibles sont les suivantes: la plus basse, inférieure à la normale, normale, supérieure à la normale et maximale. L'extrait de code suivant illustre comment vous pouvez définir les priorités de thread de deux threads à l'aide de la propriété Priority de l'objet thread.

 static void Main ()

        {

            Thread thread1 = nouveau Thread (nouveau ThreadStart (Méthode1));

            Thread thread2 = nouveau Thread (nouveau ThreadStart (Méthode2));

            thread1.Priority = ThreadPriority.Highest;

            thread2.Priority = ThreadPriority.Lowest;

            thread2.Start ();

            thread1.Start ();

            Console.Read ();

        }

        static void, méthode1 ()

        {

            pour (int i = 0; i <10; i ++)

            {

                Console.WriteLine ("Premier fil:" + i);

            }

        }

        static void, méthode2 ()

        {

            pour (int i = 0; i <10; i ++)

            {

                Console.WriteLine ("Second thread:" + i);

            }

        }

Lorsque vous exécutez l'extrait de code ci-dessus, vous verrez que le premier thread termine son exécution avant le deuxième thread même si le deuxième thread a été démarré avant le premier thread dans la méthode Main.

Les fils sont chers. Ils consomment beaucoup de ressources dans votre système pour l'initialisation, le changement de contexte et la libération des ressources qu'ils consomment. Par conséquent, le multithreading doit être utilisé judicieusement et uniquement lorsque cela est nécessaire. Lorsque vous tirez parti du multithreading, il est toujours conseillé de tirer parti des pools de threads pour créer et gérer des threads à la demande et améliorer la réactivité de votre application.