Description

Permet d'effectuer des tâches en parallèle ou des tâches sans consommer le thread de l'UI.

Liens

Créer et exécuter un thread

// Methode doit avoir une signature du type "void Methode()".
var monThread = new Thread(new ThreadStart(Methode));

// Autre moyen de créer un thread avec une méthode anonyme.
// Permet d'utiliser les variables locales dans Code.
// Attention les valeurs des variables locales de type valeur sont capturées
// à la construction du Thread, par la suite leur modification
// ne sera pas prise en compte dans Code.
var monThread = new Thread(new ThreadStart(delegate() {  /* Code */  }));
// avec une lamba expression
var monThread = new Thread(new ThreadStart(() => {  /* Code */  }));

// Lancement du thread.
monThread.Start();

// Création d'un thread exécutant une méthode avec paramètres.
// Methode doit avoir une signature du type "void Methode(object)"
var monThread = new Thread(new ParameterizedThreadStart(Methode));

// Dans le cas  d'un thread exécutant une méthode avec paramètres.
monThread.Start(new object[] { "string", 84} );

// Methode peut avoir ici n'importe quelle signature
var monThread = new Thread(() => Methode(arg1, arg2)));

Autre

// bloque le thread appelant en attendant que monThread se termine.
monThread.Join();

// bascule sur un autre thread
Thread.Sleep(0);

// attend 10ms
Thread.Sleep(10);

// une application peut se terminer même si elle a des threads background qui sont toujours actifs
// elle ne peut pas se terminer si elle a des threads foreground qui sont toujours actifs
// passe le thread en background
monThread.IsBackground = true;

// ne pas partager le champs entre les threads
// ils auront tous accès à une copie distincte
[ThreadStatic]
public static int _field;

var currentThread = Thread.CurrentThread;

Arrêter un thread

Abort

// Force brutalement le thread à s'arrêter en lançant une
// ThreadAbortException dans Methode.
monThread.Abort();

// Utilisation de Abort.
static void Methode()
{
    try
    {
        while (Thread.CurrentThread.IsAlive)
        {
            Thread.Sleep(1000);
            Console.WriteLine("Mon thread est en cours d’exécution");
        }
    }
    catch (ThreadAbortException taex)
    {
        Console.WriteLine("Mon thread à été interrompu");
    }
}

Variable conditionnelle d'arrêt

public class Worker
{
    // volatile: pas d'optimisation du compilateur car peut être 
    // atteint par plusieurs thread en même temps
    private volatile bool _shouldStop;

    public void DoWork()
    {
        while (!_shouldStop)
        {
            Console.WriteLine("Worker thread: working...");
        }
        Console.WriteLine("Worker thread: terminating gracefully.");
    }
    public void RequestStop()
    {
        _shouldStop = true;
    }
}

var workerObject = new Worker();
var monThread = new Thread(workerObject.DoWork);

// Start the worker thread.
monThread.Start();

// Request that the worker thread stop itself.
workerObject.RequestStop();

Thread pools

Au lieu de détruire un thread une fois sa tache effectuée, on le remet dans le pool pour l'affecter à une prochaine tâche. Ceci permet d'économiser le cout de la création de threads.

ThreadPool.QueueUserWorkItem((s) =>
{
    Console.WriteLine("Working on a thread from threadpool");
});