Mit TPL-wie Erreiche ich einen max-threadpool-Größe

In der Regel TPL bestimmt eine gute "Standard" - threadpool-Größe. Wenn Sie wirklich brauchen, weniger threads, siehe Gewusst wie: Erstellen eines Task-Scheduler, der die Grenzen der Grad der Parallelität

In der Regel die TPL Planer sollten tun, einen guten job zu wählen, wie viele Aufgaben gleichzeitig ausgeführt werden, aber wenn Sie wirklich wollen, um Kontrolle über es Mein blog-post zeigt, wie dies mit den Aufgaben und mit Aktionen und enthält ein Beispiel-Projekt können Sie herunterladen und ausführen, um zu sehen, beide in Aktion.

Beispiel möchten Sie vielleicht, um explizit zu begrenzen, wie viele Aufgaben sind lief gleichzeitig ist, wenn Sie anrufen, Ihre eigenen Leistungen und wollen nicht zu überlasten den server.

Für das, was du beschreibst, klingt es, wie können Sie profitieren mehr von machen sicher, dass Sie mit async/await mit Ihren Aufgaben um zu verhindern, dass unnötige thread-Verbrauch. Dies wird davon abhängen, obwohl, wenn Sie tun, CPU-gebundene Arbeit, oder IO-bound Arbeit in Ihren Aufgaben. Wenn es IO-bound sind, dann können Sie großen nutzen aus der Verwendung von async/await.

Egal, Sie fragte, wie begrenzen Sie die Anzahl der tasks, die gleichzeitig ausgeführt werden können, also hier ist etwas code zu zeigen, wie es mit den beiden Aktionen und Aufgaben.

Mit Aktionen

Wenn über Aktionen, die Sie verwenden können, die built-in .Net Parallel.Invoke-Funktion. Hier beschränken wir es zu laufen bei den meisten 3 threads parallel.

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());

Mit Aufgaben

Da man sich mit Aufgaben hier, aber, es gibt keine eingebaute Funktion. Allerdings können Sie die eine, die ich auf meinem 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);
        }
    }

Und dann erstellen Sie Ihre Liste von Aufgaben und die Funktion aufrufen, haben Sie ausgeführt, mit sagen wir maximal 3 gleichzeitige zu einer Zeit, Sie könnten dies tun:

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);