Pourquoi la tâche .net/c# est-elle plus lente que Thread ?

Petite ordure · Publié sur 03/05/2017 16:40:28

.NET 4 inclut un nouvel espace de noms, System.Threading.Tasks, qui contient des classes abstraisant la fonctionnalité de threading. Utilisez ThreadPool en arrière-plan. Une tâche représente le travail d’une unité qui doit être accomplie. Le travail de cette unité peut être exécuté dans un thread séparé ou une tâche peut être lancée de manière synchrone, ce qui nécessite d’attendre le thread principal de réglage. Utiliser des tâches vous donne non seulement une couche d’abstraction, mais aussi beaucoup de contrôle sur les threads sous-jacents.
Les tâches offrent beaucoup de flexibilité pour planifier le travail à accomplir. Par exemple, vous pouvez définir une tâche continue – ce qui doit être effectué après l’achèvement d’une tâche. Cela peut faire la différence entre une tâche réussie et une non. De plus, les tâches peuvent être organisées dans une hiérarchie. Par exemple, une tâche parent peut créer une nouvelle tâche enfant. Cela crée une dépendance de sorte que si vous annulez la tâche parente, sa tâche enfant sera également annulée.

De nos jours, il est courant d’utiliser des méthodes d’exécution de tâches, et c’est une haute performance, et je ne sais pas où en est la performance.

J’ai moi-même testé Task and Thread, et je trouve que Task est très lente, ce qui affecte grandement les performances, et le code de test est le suivant :

La connexion est visible.

Nous repassons la méthode en boucle 1000 fois, puis la méthode bloque pendant 100 millisecondes, et le résultat du test est le suivant :

Résultat:
L’exécution du thread prend 188 millisecondes
L’exécution de la tâche prend 14 671 millisecondes

La différence de vitesse entre les deux est de 78 fois !!

La tâche est très lente, je ne sais pas pourquoi cela arrive, y a-t-il un problème avec mon code de test, ou quoi ? J’espère que tu pourras expliquer pourquoi cela arrive...

Petite ordure · Publié sur 13/10/2020 10:47:17

tongli1996218 Posté le 13-10-2020 à 09:34
Pour garantir le même code que Thread, mon opération est le code suivant, et ce qui précède est un pseudo-code
PS : Appelez simplement en attendant la tâche. Retardez sans ajouter ...

Oui, merci

Temps d’exécution de la tâche : 117.0357

La connexion est visible.

Vous pouvez modifier le code comme suit :

La connexion est visible.

Task.Run remplace Task.Factory.StartNew car il décompresse automatiquement les tâches internes.
Task.WaitAll attend une tâche externe au lieu d’une tâche interne. L’utilisation de Task.Run n’a pas de tâches imbriquées.

En consultant la documentation MSDN, vous pouvez voir que la méthode Task.Delay Method crée une tâche qui se termine après un nombre spécifié de millisecondes. (En fait, un nouveau thread sera créé, et await sera ajouté pour attendre que la tâche soit exécutée, je ne sais pas si je comprends bien)

La connexion hyperlientérée est visible.

De plus, il y a une différence entre Tâche et Void

Task renvoie une méthode asynchrone qui peut attendre
La méthode asynchrone du void return ne peut pas attendre, elle fonctionne de façon asynchrone, on ne peut pas savoir quand c’est terminé, on ne peut pas surveiller le statut de cette opération asynchrone.

Référence:

La connexion hyperlientérée est visible.
La connexion hyperlientérée est visible.

En résumé : il y a un problème avec le code, je ne devrais pas utiliser Thread.Sleep à l’intérieur de la méthode Task

sususu996 · Publié sur 21/07/2020 13:09:29

J’ai eu le même problème aujourd’hui, en utilisant le multithreading pour le chiffrement AES, Task est beaucoup plus lent que Thread !!
Le propriétaire a-t-il trouvé la raison ?

tongli1996218 · Publié sur 12/10/2020 19:24:48

Ce post a été modifié pour la dernière fois par tongli1996218 le 12-10-2020 à 19:43

Après avoir testé le code du propriétaire, lorsque le programme est lancé et exécuté plusieurs fois, le temps de la tâche continue de diminuer, et sur mon ordinateur il est réduit à moins que Thread, et Thread reste stable pendant ce temps.

Il a ensuite été constaté que la méthode Thread.Sleep(100) avait un impact négatif sur Task, mais pas sur Thread, et Thread.Sleep(100) pouvait être remplacé par d’autres vérifications de programme longues comme l’auto-addition numérique ou await Task.Delay(100).

PS : Thread.Sleep met fin au temps de tranche du thread courant après appel, comme Thread.Sleep(0) met fin au temps de tranche du thread et le transfère à d’autres threads pour exécution. À l’intérieur de la tâche se trouve un pool de threads, qui peut optimiser le changement de contexte des threads et réduire le temps de perte CPU (notamment pour l’optimisation multi-cœurs), tandis que Thread.Sleep(100) perturbe la logique de commutation du pool de threads d’origine de la tâche, entraînant beaucoup de perte de temps CPU

Si vous remplacez Thread.Sleep(100) par await Task.Delay(100), vous constaterez que la consommation de temps de la tâche dépasse seulement 100 millisecondes, comme montré ci-dessous :
TaskTest() du vide privé
{
      Fil. Sommeil (100) ;
      ... Effectuez l’action
}
Remplacé par
TaskTest() privé asynchrone void
{
   en attente de la tâche. Délai (100) ;
   ... L’exécution prend plus de 100 millisecondes pour la tâche, ce qui correspond à l’original Thread.Sleep(100) pour Thread
}

Petite ordure · Publié sur 12/10/2020 22:53:05

tongli1996218 Posté le 12-10-2020 à 19:24
Après avoir testé le code du propriétaire, lorsque le programme est lancé, le temps de la tâche continue de diminuer après plusieurs exécutions, et sur mon ordinateur, il est réduit à moins que Thread...

J’ai essayé de le changer pour un code comme ceci :

La connexion est visible.

Tâche.Retard(100000);

Temps d’exécution de la tâche :14,1306 ms, le temps total est en effet très court, cependant, j’ai constaté que la méthode appelée par Task n’a pas terminé l’exécution.

tongli1996218 · Publié sur 13/10/2020 09:34:33

Ce post a été modifié pour la dernière fois par tongli1996218 le 13-10-2020 09:40

Publié le 12-10-2020 à 22:53
J’ai essayé de le changer pour un code comme ceci :
Tâche.Retard (100000) ;

Pour garantir le même code que Thread, mon opération est le code suivant, et ce qui précède est un pseudo-code
PS : Il suffit d’appeler await Task.Delay, puis d’ajouter aucun code, le thread ouvert par la tâche est immédiatement renvoyé afin de garantir la simulation de calcul-bound, vous pouvez utiliser pour (int a = 0 ; a< 1000000 ; ++a){} ; De telles méthodes à la place

TaskTest() privé asynchrone static void
      {
         en attente de la tâche. Retard (100000) ;
         Interlocked.Increment (réf run) ; Verrouillage, mais le plafond est plus petit
         if(run == j)
         {
            Chronomètre. Stop() ; Arrêtez la surveillance
            TimeSpan time = chronomètre. Écoulé ;  Obtient le temps total mesuré par l’instance courante
            Console.WriteLine(« Temps d’exécution de la tâche : » + temps de temps. TotalMillisecondes) ; Millisecondes totales
            }
      Le temps consommé est également très court

[Source] Pourquoi la tâche .net/c# est-elle plus lente que Thread ?

Sections vues