Tâche.Méthode WaitAll vs parallèle.Méthode Invoke

J'ai un exemple de code pour comparer le temps de traitement pour l'approche parallèle et L'approche de la tâche. Le but de cette expérience est de comprendre comment ils fonctionnent.

Donc mes questions sont:

1. Pourquoi Parallel a travaillé plus vite que Task?
2. mes résultats signifient-ils que je devrais utiliser Parallel au lieu de Task?
3. Où dois-je utiliser Task et where Parallel?
4. Quels sont les avantages de L'utilisation de la tâche par rapport au parallèle?

5. La tâche est-elle juste une enveloppe pour ThreadPool.Méthode QueueUserWorkItem?

       public Task SomeLongOperation()
       {
           return Task.Delay(3000);
       }
   
       static void Main(string[] args)
       {
           Program p = new Program();
           List<Task> tasks = new List<Task>();
   
           tasks.Add(Task.Factory.StartNew(() => p.SomeLongOperation()));
           tasks.Add(Task.Factory.StartNew(() => p.SomeLongOperation()));
   
           var arr = tasks.ToArray();
   
           Stopwatch sw = Stopwatch.StartNew();
           Task.WaitAll(arr);
           Console.WriteLine("Task wait all results: " + sw.Elapsed);
           sw.Stop();
   
           sw = Stopwatch.StartNew();
           Parallel.Invoke(() => p.SomeLongOperation(), () => p.SomeLongOperation());
           Console.WriteLine("Parallel invoke results: " + sw.Elapsed);
           sw.Stop();
   
           Console.ReadKey();
       }
   

Voici mes résultats de traitement:

Modifier:

Code Modifié pour ressembler à ceci:

    Program p = new Program();
    Task[] tasks = new Task[2];

    Stopwatch sw = Stopwatch.StartNew();
    tasks[0] = Task.Factory.StartNew(() => p.SomeLongOperation());
    tasks[1] = Task.Factory.StartNew(() => p.SomeLongOperation());

    Task.WaitAll(tasks);
    Console.WriteLine("Task wait all results: " + sw.Elapsed);
    sw.Stop();

    sw = Stopwatch.StartNew();
    Parallel.Invoke(() => p.SomeLongOperation(), () => p.SomeLongOperation());
    Console.WriteLine("Parallel invoke results: " + sw.Elapsed);
    sw.Stop();

Mes nouveaux résultats:

Modifier 2: Quand j'ai remplacé le code par Parallel.Invoquer pour être le premier et la tâche.WaitAll pour être deuxième la situation a été changée cardinalement. Maintenant parallèle est plus lent. Il me fait penser à l'inexactitude de mes estimations. J'ai changé de code pour ressembler à ce:

Program p = new Program();
Task[] tasks = new Task[2];

Stopwatch sw = null;
for (int i = 0; i < 10; i++)
{
    sw = Stopwatch.StartNew();
    Parallel.Invoke(() => p.SomeLongOperation(), () => p.SomeLongOperation());
    string res = sw.Elapsed.ToString();
    Console.WriteLine("Parallel invoke results: " + res);
    sw.Stop();
}

for (int i = 0; i < 10; i++)
{
    sw = Stopwatch.StartNew();
    tasks[0] = Task.Factory.StartNew(() => p.SomeLongOperation());
    tasks[1] = Task.Factory.StartNew(() => p.SomeLongOperation());
    Task.WaitAll(tasks);
    string res2 = sw.Elapsed.ToString();
    Console.WriteLine("Task wait all results: " + res2);
    sw.Stop();
}

Et voici mes nouveaux résultats:

Maintenant, je peux suggérer que cette expérience est beaucoup plus clair. Les résultats sont presque les mêmes. Parfois parallèle et parfois la tâche est plus rapide. Maintenant, mes questions sont:

1. Où dois-je utiliser Task et where Parallel?

2. Quels avantages de L'utilisation de la tâche par rapport au parallèle?

3. Est-ce que la tâche est juste une enveloppe pour ThreadPool.QueueUserWorkItem méthode?

Toute information utile pouvant clarifier ces questions est la bienvenue.