En parallèle.Invoke() sans attendre sur l'exécution à la finition

S'il vous plaît sais que je suis au courant de ce Parallèle.Invoke() est conçu pour la synchronisation des tâches. Ma question est: est-ce

Est-il possible d'appeler une méthode anonyme en utilisant quelque chose comme Parallèle.Invoquer dans l'appel à ne PAS attendre l'exécution à la fin?

Je pensais le point de l'ensemble de l'exécution en parallèle (ou en parallèle invokation) est de ne PAS avoir à attendre la fin de la tâche. Si vous voulez attendre pour un morceau de code pour terminer l'exécution, au lieu d'utiliser en Parallèle.Invoquer, pourquoi ne pas simplement appeler directement le code? Je suppose que je ne comprends pas le point de Parallèle.Invoquer. La documentation dit juste ce il fait, mais ne mentionne aucun des cas d'utilisation, lorsque cela serait plus utile que de simplement appeler directement le code.

OriginalL'auteur Anshul | 2014-01-29

  1. 9

    Si vous voulez attendre pour un morceau de code pour terminer l'exécution, au lieu d'utiliser en Parallèle.Invoquer, pourquoi ne pas simplement appeler directement le code?

    Bien normalement vous auriez du appeler Parallel.Invoke avec plusieurs pièces de travail. Si vous exécuter ces travaux dans la série, ça va (probablement) prendre plus de temps que de les exécuter en parallèle.

    "Exécuter en parallèle" n'est pas la même chose que "exécuter en arrière-plan" - vous semblez être à la recherche pour le dernier, mais ce n'est pas ce Parallel.Invoke.

    Si vous voulez juste de lancer les tâches, utiliser Task.Run (ou Task.Factory.StartNew avant .NET 4.5). Parallel.Invoke est spécifiquement pour l'exécution d'un tas d'actions en parallèle, mais alors en attente de ces actions parallèles à compléter.

    Comme un exemple concret, vous pouvez effectuer un tri par partitionnement, puis, de manière récursive le tri des deux côtés du pivot en parallèle. Cela rendra l'utilisation de plusieurs cœurs, mais vous devriez vous voulez encore d'attendre jusqu'à ce que toute sorte avaient terminé avant de continuer.

    Vous avez raison, j'étais sous l'impression que l'exécution en parallèle est le même que l'exécution en arrière-plan. Pouvez-vous me dire quelle est la différence et comment cela s'applique en Parallèle.Invoquer? Ou m'indiquer une ressource qui peut m'aider à comprendre la différence?
    L'exécution en parallèle est tout simplement l'utilisation de plusieurs cœurs pour atteindre un but. Que être fait dans une "fire and forget", mais il n'est pas toujours le cas. Voir mon edit pour prendre un exemple concret, lorsque c'est utile pour paralléliser les travaux sans en faire une tâche en arrière-plan.
    Si j'ai les 2 en Parallèle.Invoque sequeunce, ne serait pas le 2ème attendre jusqu'à ce que le premier est terminé d'être appelé? Dans ce cas, comment voulez-vous exécuter les multiples morceaux de code en parallèle en utilisant en Parallèle.Invoquer?
    ces deux opérations s'exécutent en parallèle, mais Parallèle.Invoke va attendre les deux d'entre eux à la fin. Supposons que leur temps d'exécution sont t1 et t2. Parallel.Invoke va attendre max(t1,t2)secondes.
    Qui fait sens aujourd'hui. J'ai juste eu la mauvaise idée dans ma tête à propos de ce Parallèle.Invoke est censés pour le faire.

    OriginalL'auteur Jon Skeet

  2. 6

    Simplement envelopper votre Parallel.Invoke appel à un Task si vous ne voulez pas attendre la fin.

    Task.Factory.StartNew( () =>
    {
        Parallel.Invoke( <one or more actions> );
    } );
    Et si j'avais à faire Tâche.Usine.StartNew(()=>{//tout ce}); au lieu d'utiliser en Parallèle.Invoquer? N'aurait-il pas le même effet, puisque vous êtes le démarrage d'une nouvelle tâche essentiellement?
    Bien sûr, vous devez démarrer une nouvelle tâche pour chaque action que vous souhaitez exécuter en parallèle.
    Compris. Semble que j'ai été mal à comprendre les raisons derrière Parallèle.Invoke().
    Si vous cherchez simplement à exécuter une action sur un thread d'arrière-plan, créer une tâche pour cette action. Parallel.Invoke est si vous voulez exécuter plusieurs actions simultanément
    et puis synchroniser après leur exécution

    OriginalL'auteur Moho

  3. 4

    Vous cherchez quelque chose de ce genre?

    async Task ParallelInvokeAsync(Action[] actions)
{
    var tasks = actions.Select(a => Task.Run(a));
    await Task.WhenAll(tasks);
}

    Exécution en arrière-plan:

    ParallelInvokeAsync(actions); 
MessageBox.Show("I'm working");

    Exécution en arrière-plan avec le blocage, très semblable à Parallel.Invoke:

    ParallelInvokeAsync(actions).Wait(); 
MessageBox.Show("I'm dome working");
    Je suppose que ça marcherait aussi bien. J'ai juste besoin de quelque chose qui rend l'utilisation de la TPL et exécute un morceau de code en parallèle avec la ligne en cours d'exécution. Je veux dire par là que la ligne en cours d'exécution ne devrait pas attendre la parallélisée tâche à la fin. De la tâche.Facteur.StartNew(()=>{}) satisfait à cette exigence. Je voulais garder l'appel succinct principalement.
    comment vous utilisez dépend de l'appelant. J'ai mis à jour la réponse à l'illustrer. Théoriquement, Task.Factory.StartNew(() => Parallel.Invoke(actions)) serait de créer un fil plus que la ParallelInvokeAsync(actions) ci-dessus.

    OriginalL'auteur noseratio