
| auteur : abelman | Pour créer un thread, il faut utiliser la classe System.Threading.Thread.
Considérons que l'on dispose d'une Form.
Nous avons besoin de déclarer notre objet thread à l'intérieur de la Form.
using System. Threading;
public class Threads : System. Windows. Forms. Form
{
private Thread _threadCalculs1;
}
|
La fonction exécutée par le thread a une signature imposée par le .NET Framework. Il s'agit du délégué System.Threading.ThreadStart.
C'est une fonction qui ne prend aucun paramètre et ne possède pas de valeur de retour.
On peut la déclarer ainsi dans notre Form.
using System. Threading;
public class Threads : System. Windows. Forms. Form
{
private void ThrFunc1 ()
{
try
{
Calculs (1000 );
}
catch (Exception ex)
{
Debug. WriteLine (ex. ToString ());
}
}
}
|
Pour démarrer le thread, on utilise la fonction Start de la classe Thread.
using System. Threading;
public class Threads : System. Windows. Forms. Form
{
private void StartThread ()
{
_threadCalculs1 = new Thread (new ThreadStart (ThrFunc1));
_threadCalculs1. Name = " Thread1 " ;
_threadCalculs1. Start ();
}
}
|
|
lien : System.Threading.Thread (MSDN)
|
| auteurs : abelman, Thomas Lebrun |
Le délégué System.Threading.ThreadStart utilisé pour les fonctions de thread ne prend pas de paramètres.
Pour passer des paramètres à un thread, il vous faut créer une classe pour contenir les paramètres et la méthode du thread.
public class ThreadParametre
{
private string _text;
private int _entier;
public ThreadParametre (string texte, int entier)
{
_text = texte;
_entier = entier;
}
public void ExecuteThread ()
{
for (int i = 0 ; i < _entier; i+ + )
{
Console. WriteLine (" Index : " + i);
Console. WriteLine (" Message : " + _text);
}
}
}
public class Exemple
{
public static void Main ()
{
ThreadParametre ExempleThread = new ThreadParametre (" Message de test " , 5 );
Thread t = new Thread (new ThreadStart (ExempleThread. ExecuteThread));
t. Start ();
}
}
|
|
lien : System.Threading.Thread (MSDN)
|
| auteur : abelman |
Le meilleur moyen d'arrêter un thread est de laisser sa fonction se terminer.
Si une fonction de thread s'exécute en continu dans une boucle, il est nécessaire d'écrire un code qui prévoit une condition pour sortir de la boucle. Cette condition doit pouvoir être modifiée par d'autres threads.
Reprenons l'exemple de notre Form (voir Q/R création d'un thread).
Pour signaler au thread que nous souhaitons qu'il s'arrête, nous allons utiliser un objet de la classe System.Threading.AutoResetEvent.
Dans la boucle de la fonction du thread, nous faisons attendre le thread pendant un court laps de temps. Si l'objet AutoResetEvent passe à l'état signalé, alors on sort du thread.
using System. Threading;
public class Thread : System. Windows. Forms. Form
{
private AutoResetEvent _endThreadCalculsEvent = new AutoResetEvent (false );
private void Button2_Click (Object sender, System. EventArgs e)
{
_endThreadCalculsEvent. Set ();
_threadCalculs1. Join ();
}
private void ThrFunc1 ()
{
try
{
Calculs (1000 );
}
catch (Exception ex)
{
Debug. WriteLine (ex. ToString ());
}
}
private void Calculs (int tempor)
{
while (! _endThreadCalculsEvent. WaitOne (tempo, false ))
{
}
}
}
|
Il existe un moyen plus radical d'arrêter un thread, c'est l'utilisation de la fonction Thread.Abort.
Lorsque vous appelez Abort, le Runtime lève une exception ThreadAbortException que le thread peut alors intercepter.
C'est aussi pourquoi il est déconseillé d'utiliser Abort car on ne peut prévoir où en est le thread dans son traitement. Lever une exception peut interrompre le thread alors qu'il est dans une partie du code qu'il doit terminer avant de sortir.
Un des exemples où on peut utiliser Abort sans risque : la fonction du thread est bloquée infiniment sur un appel (une attente de connexion socket par exemple)
private void AbortThread ()
{
_threadCalculs1. Abort ();
_threadCalculs1. Join ();
}
|
Un thread terminé ne peut plus être relancé. Il faut instancier un nouvel objet Thread pour chaque démarrage de thread.
|
lien : System.Threading.Thread (MSDN)
lien : System.Threading.AutoResetEvent (MSDN)
|
| auteur : sam_XIII |
Tout d'abord pensez à la clause "using System.Threading".
Pour changer le nom du thread courant, ajouter la ligne de code suivante :
Thread. CurrentThread. Name = " MainThread " ;
|
Ici on donne le nom "MainThread" au thread courrant.
Si vous devez réaliser cela pour le thread principal, alors il faut ajouter cette ligne avant le "Application.Run" .
|
| auteur : cardi |
La ligne suivante permet de mettre un terme à la tranche de temps que le Thread a pour utiliser le processeur :
|
| auteur : cardi |
La classe Interlocked fournit des méthodes permettant d'effectuer des opérations mathématiques de manière atomique lorsque plusieurs threads se partagent des variables.
int SharedValue = 100 ;
Interlocked. Add (ref SharedValue, 10 );
Interlocked. Add (ref SharedValue, - 10 );
Interlocked. Increment (ref SharedValue);
Interlocked. Decrement (ref SharedValue);
int SharedValue2 = 50 ;
Interlocked. Exchange (ref SharedValue, SharedValue2);
Interlocked. CompareExchange (ref SharedValue, 100 , 50 );
long SharedValueLong = 30 ;
long ValueSafe = Interlocked. Read (ref SharedValueLong);
|
A noter que les membres de cette classe ne lèvent pas d'exception.
|
lien : System.Threading.Interlocked (MSDN)
|
| auteur : cardi |
La classe Monitor permet à un thread de mettre un verrou sur des objets. Ainsi, aucun autre thread ne pourra mettre son verrou sur les objets déjà verrouillés.
Monitor. Enter (this );
Monitor. Exit (this );
|
|
lien : System.Threading.Monitor (MSDN)
|
| auteur : cardi |
La classe Mutex permet à un thread d'avoir un accès exclusif à une portion de code, les autres threads étant bloqués s'ils désirent accéder à cette portion de code.
static class MutexExample
{
static Mutex monMutex;
static void Main ()
{
monMutex = new Mutex ();
Thread T1 = new Thread (new ThreadStart (FonctionA));
Thread T2 = new Thread (new ThreadStart (FonctionB));
T1. Start ();
T2. Start ();
T1. Join ();
T2. Join ();
Console. ReadLine ();
}
< summary >
< / summary >
static void FonctionA ()
{
for (int i = 0 ; i < 3 ; i+ + )
{
Console. WriteLine (" Thread A > J'ai faim " );
Manger ();
Console. WriteLine (" Thread A > J'en peux plus... " );
Thread. Sleep (100 );
}
Console. WriteLine (" Thread A > Oh non, déjà fini :( " );
}
< summary >
< / summary >
static void FonctionB ()
{
for (int i = 0 ; i < 3 ; i+ + )
{
Console. WriteLine (" Thread B > J'ai faim " );
Manger ();
Console. WriteLine (" Thread B > J'en peux plus... " );
Thread. Sleep (200 );
}
Console. WriteLine (" Thread B > Oh non, déjà fini :( " );
}
< summary >
< / summary >
static void Manger ()
{
monMutex. WaitOne ();
Thread. Sleep (50 );
monMutex. ReleaseMutex ();
}
}
|
Attention toutefois, depuis la version 2 du Framework, une exception AbandonedMutexException est levée lorsqu'un thread désire acquérir un Mutex qui appartenait à un thread qui s'est terminé sans le libérer.
|
lien : System.Threading.Mutex (MSDN)
|
Consultez les autres F.A.Q's
Les sources présentés sur cette page sont libres de droits,
et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Copyright ©2010
Developpez LLC. Tous droits réservés Developpez LLC.
Aucune reproduction, même partielle, ne peut être faite de ce site et de
l'ensemble de son contenu : textes, documents et images sans l'autorisation
expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans
de prison et jusqu'à 300 000 E de dommages et intérêts.
Cette page est déposée à la SACD.
|