À l'aide de TPL comment puis-je configurer un max la taille du pool de threads

Généralement TPL détermine une bonne "par défaut" la taille du pool de threads. Si vous avez vraiment besoin de moins de threads, voir Comment: Créer un Planificateur de Tâches Qui Limite le Degré de Simultanéité

OriginalL'auteur Chris Shain

Généralement le TPL planificateur doit faire un bon travail de choisir le nombre de tâches à exécuter simultanément, mais si vous voulez vraiment avoir le contrôle Mon blog montre comment faire les deux avec les Tâches et les Actions, et fournit un exemple de projet que vous pouvez télécharger et de l'exécuter pour voir à la fois dans l'action.

Un exemple de lorsque vous souhaitez explicitement à limiter le nombre de tâches sont lancées simultanément, c'est quand vous appelez de vos propres services et qui ne veulent pas surcharger votre serveur.

Pour ce que vous décrivez, il semble que vous pouvez bénéficier de plus de vous assurer que vous êtes en utilisant async/await avec vos tâches afin de prévenir inutile fil de la consommation. Cela dépendra bien sur si vous faites le CPU de travail, ou IO-travail liées dans vos tâches. Si c'est IO-lié, alors vous pouvez bénéficier grandement de l'aide async/await.

En soit, vous demande comment vous pouvez limiter le nombre de tâches qui s'exécutent simultanément, alors voici un peu de code pour montrer comment le faire avec à la fois des Actions et des Tâches.

Avec Des Actions

Si à l'aide d'Actions, vous pouvez utiliser le microphone .Net Parallèle.Appeler la fonction. Ici nous limiter à l'exécution d'au plus 3 threads en parallèle.

var listOfActions = new List<Action>();
for (int i = 0; i < 10; i++)
{
    //Note that we create the Action here, but do not start it.
    listOfActions.Add(() => DoSomething());
}

var options = new ParallelOptions {MaxDegreeOfParallelism = 3};
Parallel.Invoke(options, listOfActions.ToArray());

Avec Des Tâches

Puisque vous êtes à l'aide de Tâches ici cependant, il n'existe pas de fonction intégrée. Toutefois, vous pouvez utiliser celui que j'sur mon blog.

    ///<summary>
///Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
///<para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
///</summary>
///<param name="tasksToRun">The tasks to run.</param>
///<param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
///<param name="cancellationToken">The cancellation token.</param>
public static void StartAndWaitAllThrottled(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, CancellationToken cancellationToken = new CancellationToken())
{
StartAndWaitAllThrottled(tasksToRun, maxTasksToRunInParallel, -1, cancellationToken);
}
///<summary>
///Starts the given tasks and waits for them to complete. This will run, at most, the specified number of tasks in parallel.
///<para>NOTE: If one of the given tasks has already been started, an exception will be thrown.</para>
///</summary>
///<param name="tasksToRun">The tasks to run.</param>
///<param name="maxTasksToRunInParallel">The maximum number of tasks to run in parallel.</param>
///<param name="timeoutInMilliseconds">The maximum milliseconds we should allow the max tasks to run in parallel before allowing another task to start. Specify -1 to wait indefinitely.</param>
///<param name="cancellationToken">The cancellation token.</param>
public static void StartAndWaitAllThrottled(IEnumerable<Task> tasksToRun, int maxTasksToRunInParallel, int timeoutInMilliseconds, CancellationToken cancellationToken = new CancellationToken())
{
//Convert to a list of tasks so that we don&#39;t enumerate over it multiple times needlessly.
var tasks = tasksToRun.ToList();
using (var throttler = new SemaphoreSlim(maxTasksToRunInParallel))
{
var postTaskTasks = new List<Task>();
//Have each task notify the throttler when it completes so that it decrements the number of tasks currently running.
tasks.ForEach(t => postTaskTasks.Add(t.ContinueWith(tsk => throttler.Release())));
//Start running each task.
foreach (var task in tasks)
{
//Increment the number of tasks currently running and wait if too many are running.
throttler.Wait(timeoutInMilliseconds, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
task.Start();
}
//Wait for all of the provided tasks to complete.
//We wait on the list of "post" tasks instead of the original tasks, otherwise there is a potential race condition where the throttler&#39;s using block is exited before some Tasks have had their "post" action completed, which references the throttler, resulting in an exception due to accessing a disposed object.
Task.WaitAll(postTaskTasks.ToArray(), cancellationToken);
}
}

Et puis la création de votre liste de Tâches et l'appel de la fonction à les exécuter, à dire un maximum de 3 simultanée à un moment, vous pourriez faire ceci:

var listOfTasks = new List<Task>();
for (int i = 0; i < 10; i++)
{
var count = i;
//Note that we create the Task here, but do not start it.
listOfTasks.Add(new Task(() => Something()));
}
Tasks.StartAndWaitAllThrottled(listOfTasks, 3);

OriginalL'auteur deadlydog