Fil de discussion C#

L'article suivant fournit un aperçu du thread C#. Le chemin d'exécution du programme est défini comme thread et un flux de contrôle unique est défini par chaque thread. Différents chemins d'exécution ou threads doivent être définis, chaque thread étant responsable d'un travail particulier lorsque l'application comprend des opérations compliquées et chronophages. Ces processus de threads qui sont légers et les systèmes d'exploitation modernes implémentant la programmation simultanée sont l'un des exemples d'utilisation de threads et en utilisant des threads, les gaspillages de cycle de l'unité centrale de traitement sont économisés et l'efficacité de l'application est augmentée.

Syntaxe :

public sealed class Thread: System.Runtime.ConstrainedExecution.CriticalFinalizerObject

Fonctionnement de la classe Thread C#

L'heure à laquelle un objet de la classe System.Threading.Thread est créé lorsque le cycle de vie du thread démarre. Lorsqu'il y a terminaison du thread ou achèvement de l'exécution du thread, le thread est créé et se termine.

Il existe plusieurs états dans le cycle de vie d'un thread.

1. L'état non démarré : Cet état est une situation dans laquelle la méthode de démarrage n'est pas appelée mais une instance du thread est créée.

2. L'état Prêt : Cet état est une situation dans laquelle le thread est prêt à s'exécuter et attend le cycle de l'unité centrale de traitement.

3. L'état non exécutable : Cet état est une situation dans laquelle le thread ne peut pas être exécuté lorsque :

• Il y a eu un appel à la méthode Sleep.
• Il y a eu un appel à la méthode Wait.
• Il y a eu un blocage par les opérations d'entrée/sortie.

4. L'état mort : Cet état est une situation dans laquelle l'exécution du thread est terminée, ou l'exécution du thread est interrompue.

• Pour travailler avec des threads en C#, nous devons utiliser la classe System.Threading.Thread.
• Lorsque vous travaillez avec des applications multithread, des threads individuels peuvent être créés et accessibles à l'aide de la classe System.Threading.Thread en C#.
• Le thread qui sera exécuté en premier dans l'ensemble du processus est appelé thread principal.
• Le thread principal est automatiquement créé lorsque l'exécution du programme C# commence.
• Les threads créés à l'aide des classes de Thread sont appelés comme threads enfants du thread principal.
• La propriété CurrentThread de la classe Thread est utilisée pour accéder à un fil de discussion.

Le programme ci-dessous montre l'exécution du thread principal :

Code :

using System;
using System.Threading;
//a namespace called multithreading is created
namespace Multithreading
{
//a class called mainthread is created under multithreading namespace
class MainThread
{
//main method is called
static void Main(string[] args)
{
//an instance of the thread class is created
Thread thr = Thread.CurrentThread;
//Name method of thread class is accessed using the instance of the thread class
thr.Name = "Thread Class";
//the content is displayed as the output
Console.WriteLine("Welcome to {0}", thr.Name);
Console.ReadKey();
}
}
}

Sortie :

Dans le programme ci-dessus, un espace de noms appelé multithreading est créé. Ensuite, une classe appelée mainthread est créée sous un espace de noms multithread. Ensuite, une méthode principale est appelée. Ensuite, une instance de la classe thread est créée. Ensuite, la méthode Name de la classe de thread est accessible à l’aide de l’instance de la classe de thread. Enfin, la sortie est affichée à l'écran.

Méthodes de classe Thread

Vous trouverez ci-dessous les différentes méthodes de la classe thread :

1. Abandonner()

Chaque fois que la méthode Abort() est invoquée sur un thread, ThreadAbortException est levée et le processus de terminaison du thread commence. La fin du thread est provoquée par l'appel de cette méthode.

Exemple : 

Code :

using System;
using System.Threading;
class ExThread
{
public void thr()
{
for (int y = 0; y < 3; y++)
{
Console.WriteLine(y);
}
}
}
class Example
{
public static void Main()
{
ExThread ob = new ExThread();
Thread th = new Thread(new ThreadStart(ob.thr));
th.Start();
Console.WriteLine("Aborting the thread");
th.Abort();
}
}

Sortie :

2. Interruption()

Chaque fois que la méthode Interrupt() est appelée, un thread qui est dans l'état de thread WaitSleepJoin est interrompu.

3. Rejoindre()

Chaque fois que la méthode Join() est appelée, un thread appelant est bloqué jusqu'à la fin d'un thread et le pompage standard COM et SendMessage continue d'être effectué avec le blocage du thread.

Exemple pour implémenter Interrupt() et Join() :

Code :

using System;
using System.Threading;
class Thr
{
Thread th;
public Thr(String name1)
{
th = new Thread(this.Runaway);
th.Name = name1;
th.Start();
}
public void Runaway()
{
Thread th1 = Thread.CurrentThread;
try
{
Console.WriteLine(" Execution of " + th1.Name + " has begun");
for(int y=0; y<3; y++)
{
Console.WriteLine(" Printing of " + th1.Name + " has begun" + y);
Thread.Sleep(200);
}
Console.WriteLine(" Execution of " + th1.Name + " is finished");
}
catch(ThreadInterruptedException e)
{
Console.WriteLine("Thread Interruption" + e);
}
}
public static void Main(String[] ar)
{
Thr ob = new Thr("Thread demo");
ob.th.Interrupt();
ob.th.Join();
}
}

Sortie :

4. RéinitialiserAbort()

Chaque fois que la méthode ResetAbort() est appelée, la demande de terminaison du thread en cours est annulée.

Exemple :

Code :

using System;
using System.Threading;
using System.Security.Permissions;
class Thread1
{
public void Jobthread()
{
try
{
for (int r = 0; r < 3; r++)
{
Console.WriteLine(" Working of thread has begun ");
Thread.Sleep(10);
}
}
catch (ThreadAbortException e)
{
Console.WriteLine("ThreadAbortException is caught and must be reset");
Console.WriteLine("The message looks like this: {0}", e.Message);
Thread.ResetAbort();
}
Console.WriteLine("Thread is working fine");
Thread.Sleep(200);
Console.WriteLine("Thread is done");
}
}
class Driver
{
public static void Main()
{
Thread1 obj = new Thread1();
Thread Th = new Thread(obj.Jobthread);
Th.Start();
Thread.Sleep(100);
Console.WriteLine("thread abort");
Th.Abort();
Th.Join();
Console.WriteLine("end of main thread");
}
}

Sortie :

5. Début()

Chaque fois que la méthode Start() est appelée, un thread est démarré.

Exemple :

Code :

using System;
using System.Threading;
class Test
{
static void Main()
{
Thread td = new Thread (new ThreadStart (Got));
td.Start();
}
static void Got()
{
Console.WriteLine ("this is thread Start() method");
}
}

Sortie :

6. Veille (int millisecondesTimeout)

Chaque fois que la méthode Sleep(int millisecondsTimeout) est appelée, le thread est mis en pause pendant la période spécifiée.

Exemple :

Code :

using System;
using System.Threading;
namespace Examplethr
{
class MyThread
{
static void Main(string[] args)
{
Thread th = Thread.CurrentThread;
th.Name = "This is the First Thread";
Console.WriteLine("The Name of the thread is : {0}", th.Name);
Console.WriteLine("The priority of the thread is : {0}", th.Priority);
Console.WriteLine("Pausing the child thread");
// using Sleep() method
Thread.Sleep(100);
Console.WriteLine("Resuming the child thread");
Console.ReadKey();
}
}
}

Sortie :

7. Suspend()

Whenever Suspend() method is called, the current thread is suspended if it is not suspended.

8. Resume()

Whenever Resume() method is called, the suspended thread is resumed.

9. Yield()

Whenever Yield() method is called, the calling thread must result in execution to the other thread which is ready to start running on the current processor. The thread to yield to is selected by the operating system.

Example to implement Suspend() Resume() and Yield()

Code:

using System;
using System.Runtime.CompilerServices;
using System.Threading;
class Program
{
public static void Main ()
{
bool finish = false;
Thread th = new Thread (() => {
while (!finish) {}
});
Thread th1 = new Thread (() => {
while (!finish) {
GC.Collect ();
Thread.Yield ();
}
});
th.Start ();
th1.Start ();
Thread.Sleep (10);
for (int j = 0; j < 5 * 4 * 2; ++j) {
th.Suspend ();
Thread.Yield ();
th.Resume ();
if ((j + 1) % (5) == 0)
Console.Write ("Hello ");
if ((j + 1) % (5 * 4) == 0)
Console.WriteLine ();
}
finish = true;
th.Join ();
th1.Join ();
}
}

Output:

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!