Système.Le filetage.Tâches - Limiter le nombre de Tâches simultanées

Je sais que c'est un vieux thread, mais je voulais juste partager ma solution à ce problème: l'utilisation des sémaphores.

(C'est en C#)

private void RunAllActions(IEnumerable<Action> actions, int maxConcurrency)
{
    using(SemaphoreSlim concurrencySemaphore = new SemaphoreSlim(maxConcurrency))
    {
        foreach(Action action in actions)
        {
            Task.Factory.StartNew(() =>
            {
                concurrencySemaphore.Wait();
                try
                {
                    action();
                }
                finally
                {
                    concurrencySemaphore.Release();
                }
            });
        }
    }
}

C# équivalent de l'échantillon fourni par James

Action[] actionsArray = new Action[] {
new Action(() => DoComputation1()),
new Action(() => DoComputation2()),
    //...
new Action(() => DoComputation100())
  };

   System.Threading.Tasks.Parallel.Invoke(new Tasks.ParallelOptions {MaxDegreeOfParallelism =  5 }, actionsArray)

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.

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 5 threads en parallèle.

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

var options = new ParallelOptions {MaxDegreeOfParallelism = 5};
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 5 simultanée à un moment, vous pourriez faire ceci:

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

Si votre programme utilise des webservices nombre de connexions simultanées sera limitée à ServicePointManager.DefaultConnectionLimit de la propriété. Si vous voulez 5 connexions simultanées, il ne suffit pas d'utiliser Arrow_Raider de la solution. Vous devez également augmenter ServicePointManager.DefaultConnectionLimit car il est à seulement 2 par défaut.