Comprendre les fils d’exécution et les tâches

Bienvenue dans la prochaine leçon ! Dans cette leçon, vous découvrirez les fils d’exécution et les tâches en C#, qui vous permettent d’exécuter plusieurs opérations simultanément pour améliorer les performances. Commençons !

Qu’est-ce que la gestion des fils d’exécution ?

La gestion des fils d’exécution consiste à exécuter plusieurs opérations simultanément. Chaque fil d’exécution représente un flux de contrôle distinct dans votre application.

Point clé : La gestion des fils d’exécution améliore les performances en utilisant plusieurs cœurs de processeur pour une exécution simultanée.

Créer et démarrer des fils d’exécution

Vous pouvez créer et démarrer des fils d’exécution à l’aide de la classe Thread. Exemple :

using System;
using System.Threading;

class Program {
    static void Main() {
        Thread thread = new Thread(PrintNumbers);
        thread.Start();

        Console.WriteLine("Main thread is running...");
    }

    static void PrintNumbers() {
        for (int i = 1; i <= 5; i++) {
            Console.WriteLine(i);
            Thread.Sleep(1000); // Pause for 1 second
        }
    }
}

Introduction aux tâches

Les tâches offrent une abstraction de plus haut niveau pour la programmation simultanée par rapport aux fils d’exécution. La classe Task fait partie de la bibliothèque de tâches parallèles (TPL) en C#.

Exemple : créer et démarrer une tâche :

Astuce : Les tâches sont plus faciles à gérer et offrent une meilleure gestion des erreurs que les fils d’exécution.

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        Task task = Task.Run(() => {
            for (int i = 1; i <= 5; i++) {
                Console.WriteLine(i);
                Task.Delay(1000).Wait();
            }
        });

        Console.WriteLine("Main thread is running...");
        task.Wait(); // Wait for the task to complete
    }
}

Utiliser Parallel.For et Parallel.ForEach

La classe Parallel en C# vous permet d’exécuter des boucles en parallèle pour améliorer les performances. Exemple :

Point clé : Utilisez Parallel.For et Parallel.ForEach pour les tâches qui traitent beaucoup de données et peuvent être exécutées simultanément.

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        Parallel.For(0, 5, i => {
            Console.WriteLine($"Processing {i} on thread {Task.CurrentId}");
        });

        Console.WriteLine("All tasks completed.");
    }
}

Gérer les exceptions dans les tâches

Vous pouvez intercepter les exceptions dans les tâches à l’aide d’un bloc try-catch ou de la propriété Task.Exception. Exemple :

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        try {
            Task task = Task.Run(() => {
                throw new InvalidOperationException("Task failed!");
            });

            task.Wait();
        } catch (AggregateException ex) {
            Console.WriteLine("Error: " + ex.InnerException.Message);
        }
    }
}

Exercice pratique

Créez un programme qui démarre plusieurs tâches pour traiter des nombres en parallèle et afficher leurs carrés. Exemple :

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        int[] numbers = { 1, 2, 3, 4, 5 };

        Parallel.ForEach(numbers, number => {
            Console.WriteLine($"Square of {number}: {number * number}");
        });
    }
}

Bonnes pratiques pour les fils d’exécution et les tâches

Voici quelques bonnes pratiques :

• Préférez Task à Thread pour la programmation simultanée de haut niveau.
• Utilisez les classes Parallel pour les opérations qui traitent beaucoup de données.
• Gérez correctement les exceptions pour garantir la robustesse des applications.
• Limitez le nombre de fils d’exécution ou de tâches afin d’éviter la concurrence pour les ressources.

Astuce : Utilisez la programmation async lorsque les opérations d’E/S prédominent, et utilisez les fils d’exécution ou les tâches pour les tâches liées au CPU.

Bravo !

Félicitations ! Vous avez appris les bases des fils d’exécution et des tâches pour la programmation simultanée en C#. Dans la prochaine leçon, nous étudierons les delegate et les expressions lambda, deux fonctionnalités puissantes de la programmation fonctionnelle. Continuons à coder !