How Can I Limit Concurrent Task Execution to 10 using C# Tasks?

Concurrency Management with Tasks: Limiting Concurrent Execution

In your scenario, you aim to run a set of 100 tasks concurrently, but only allow a maximum of 10 tasks to execute at any given time. This involves managing concurrency effectively to ensure proper task execution and resource utilization.

To address this requirement using Tasks, you can employ the following approach:

// Define a SemaphoreSlim to limit concurrent tasks to 10
SemaphoreSlim maxThread = new SemaphoreSlim(10);

// Iterate through the tasks
for (int i = 0; i < 115; i++)
{
    // Wait for the SemaphoreSlim to allow a new task to execute
    maxThread.Wait();

    // Create a new task and schedule it
    Task.Factory.StartNew(() =>
    {
        // Perform the task's operation
    }, TaskCreationOptions.LongRunning)

    // Release the SemaphoreSlim when the task completes
    .ContinueWith((task) => maxThread.Release());
}

In this implementation:

1. A SemaphoreSlim named maxThread is created with an initial count of 10, representing the maximum number of concurrent tasks allowed.
2. The loop iterates through the 115 tasks.
3. Within each iteration, the code waits for the SemaphoreSlim to acquire a permit, ensuring that no more than 10 tasks are running simultaneously.
4. Once a permit is acquired, a new task is created using Task.Factory.StartNew. The TaskCreationOptions.LongRunning option indicates that the task can take a longer time to execute.
5. A continuation is added to the task using ContinueWith. When the task completes, the continuation releases the permit on the SemaphoreSlim, allowing another waiting task to start executing.

This approach ensures that only 10 tasks run at any given moment, effectively managing concurrency and preventing resource starvation.

The above is the detailed content of How Can I Limit Concurrent Task Execution to 10 using C# Tasks?. For more information, please follow other related articles on the PHP Chinese website!