Thread.Sleep() en C#

1. Pourquoi thread.sleep() est nuisible en C#
2. Comment thread.sleep() fonctionne en C#
3. Programmation asynchrone
4. Exécuter deux méthodes simultanément (mots clés async et wait en C#)

Dans ce guide, nous apprendrons pourquoi l’utilisation de thread.sleep() en C# est considérée comme nuisible et pourquoi cette approche particulière ne doit pas être utilisée.

Que se passe-t-il en utilisant thread.sleep() ? Existe-t-il une approche alternative ?

Découvrez tout dans ce guide. Plongeons dedans.

Pourquoi thread.sleep() est nuisible en C#

Pour comprendre pourquoi thread.sleep() est nuisible, nous devons comprendre le travail derrière cette méthode. Eh bien, en C#, la méthode sleep a son utilité.

Vous pouvez l’utiliser pour mettre en pause ou suspendre la fonctionnalité actuelle (exécution du thread) pendant une période spécifique. Nous pouvons passer le temps en millisecondes pour suspendre l’exécution du thread pendant un certain temps.

Nous pouvons également utiliser la propriété TimeSpan, comme indiqué dans le code ci-dessous.

// Time in milliseconds
Thread.Sleep(5000);
Or
    // Time in hours, minutes, seconds
    TimeSpan tsObj = new TimeSpan(0, 0, 5);
Thread.Sleep(tsObj);

Maintenant, les deux approches ci-dessus arrêteront le programme pendant cinq secondes. Cela signifie que, via le code ci-dessus, nous essayons de suspendre le thread pendant 1 seconde.

Mais, quel est le sens de tout cela ? Comprenons le fonctionnement de celui-ci.

Comment thread.sleep() fonctionne en C#

Nous savons tous qu’un programme s’exécute ligne par ligne, ce qui signifie que l’ensemble du programme s’exécute de manière synchrone, une ligne après l’autre. Parfois, lors de la programmation, nous devons effectuer une tâche qui prend un certain temps à accomplir.

Par exemple, en récupérant les données d’une API, nous pouvons utiliser la fonction sleep pour la laisser attendre, obtenir ces données de l’API et exécuter le reste du programme plus tard. C’est nécessaire, mais c’est une approche très nuisible et médiocre.

Par exemple, les données que nous essayons de récupérer peuvent être volumineuses et prendre du temps. Notre programme sera arrêté pendant cette période ; ce n’est pas une approche idéale.

Thread.Sleep(n) signifie arrêter le thread en cours d’exécution pendant autant de tranches de temps (également appelées quantums de thread) que possible en n millisecondes. La durée d’une tranche de temps varie en fonction de la version/du type de Windows et du processeur utilisé, mais elle dure généralement entre 15 et 30 millisecondes.

Cela indique que le thread bloquera probablement plus de n millisecondes. Il est peu probable que votre fil se réveille précisément n millisecondes plus tard.

Ainsi, Thread.Sleep ne sert à rien dans le timing.

Les threads sont une ressource finie qui nécessite environ 200 000 cycles de création et 100 000 cycles de destruction. Par défaut, ils utilisent 2 000 à 8 000 cycles pour chaque transition de contexte et réservent 1 mégaoctet de mémoire virtuelle pour leur pile.

Quelle est l’approche alternative

Nous avons parfois besoin de retarder notre thread pour que le programme fonctionne parfaitement. Comme mentionné ci-dessus, nous pourrions avoir besoin de récupérer certaines données API, ce qui prend du temps.

Mais arrêter tout le programme à cause de cela est une mauvaise approche. Alors, comment éviter cela ?

Initions-nous à la programmation asynchrone.

Programmation asynchrone

Les mots clés async et wait en C# contribuent à rendre la programmation asynchrone très courante de nos jours. L’ensemble de l’application devra attendre pour terminer l’opération lors de l’utilisation de l’interface utilisateur et utiliser une méthode longue qui prendra beaucoup de temps, comme lire un fichier volumineux ou cliquer sur un bouton.

En d’autres termes, si un processus d’une application synchrone est bloqué, l’application entière est également arrêtée et notre application cesse de fonctionner jusqu’à ce que la tâche entière soit terminée.

Dans cette situation, la programmation asynchrone est très utile. L’application peut poursuivre des tâches qui ne dépendent pas de l’achèvement en utilisant la programmation asynchrone.

A l’aide des mots-clés async et wait, nous obtiendrons tous les avantages de la programmation asynchrone conventionnelle avec beaucoup moins de travail.

Exécuter deux méthodes simultanément (mots clés async et wait en C#)

Disons que nous avons deux méthodes, FirstMethod() et SecondMethod(), qui sont indépendantes l’une de l’autre et que FirstMethod() prend beaucoup de temps pour effectuer sa tâche.

La programmation synchrone commence par FirstMethod() et attend qu’elle se termine avant de passer à SecondMethod(), qui est alors exécutée. Même si les deux procédures sont indépendantes, le processus prendra beaucoup de temps.

Nous pouvons exécuter toutes les fonctions simultanément en utilisant une simple programmation de threads, mais cela bloquerait l’interface utilisateur pendant que nous attendons que les tâches soient terminées. En programmation traditionnelle, nous aurions besoin d’écrire beaucoup de code pour résoudre ce problème, mais si nous utilisons les mots-clés async et wait, nous pouvons résoudre le problème avec beaucoup moins de code.

Nous verrons également d’autres exemples, et dans ces cas, lorsque SecondMethod() dépend de FirstMethod(), il utilisera le mot-clé wait pour attendre que FirstMethod() ait fini de s’exécuter.

En C#, async et wait sont des marqueurs de code qui indiquent où le contrôle doit revenir lorsqu’une tâche est terminée.

Commencer par des exemples concrets vous aidera à mieux comprendre la programmation derrière eux. Jetez un oeil au code suivant.

class Program {
  static void Main(string[] args) {
    FirstMethod();
    SecondMethod();
    Console.ReadKey();
  }

  public static async Task FirstMethod() {
    await Task.Run(() => {
      for (int i = 0; i < 100; i++) {
        Console.WriteLine(" First Method");
        // Do something
        Task.Delay(100).Wait();
      }
    });
  }

  public static void SecondMethod() {
    for (int i = 0; i < 25; i++) {
      Console.WriteLine(" Second Method ");
      // Do something
      Task.Delay(100).Wait();
    }
  }
}

La sortie du code ci-dessus sera la suivante.

First Method
Second Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
First Method
Second Method
Second Method
Second Method
Second Method
Second Method

Comme vous pouvez le voir dans le code ci-dessus, tout ce programme ne s’arrête pas simplement parce que nous devons arrêter d’exécuter un thread. Ils peuvent tous deux fonctionner simultanément avec l’utilisation de la programmation asynchrone.

Disons que vous êtes à un moment donné où vous devez récupérer des données d’API, ce qui prend du temps. Ainsi, le programme passera à la ligne suivante sans obtenir les données, nous devons donc le retarder un peu pour obtenir ces données, puis passer à la ligne suivante.