Throttling asynchronous tasks

This is copied from this Stack Overflow Post

I would like to run a bunch of async tasks, with a limit on how many tasks may be pending completion at any given time.

Say you have 1000 URLs, and you only want to have 50 requests open at a time; but as soon as one request completes, you open up a connection to the next URL in the list. That way, there are always exactly 50 connections open at a time, until the URL list is exhausted.

I also want to utilize a given number of threads if possible.

I came up with an extension method, ThrottleTasksAsync that does what I want. Is there a simpler solution already out there? I would assume that this is a common scenario.


class Program
    static void Main(string[] args)
        Enumerable.Range(1, 10).ThrottleTasksAsync(5, 2, async i => { Console.WriteLine(i); return i; }).Wait();

        Console.WriteLine("Press a key to exit...");

Here is the code:

public static class EnumerableExtensions
    public static async Task<Result_T[]> ThrottleTasksAsync<Enumerable_T, Result_T>(this IEnumerable<Enumerable_T> enumerable, int maxConcurrentTasks, int maxDegreeOfParallelism, Func<Enumerable_T, Task<Result_T>> taskToRun)
        var blockingQueue = new BlockingCollection<Enumerable_T>(new ConcurrentBag<Enumerable_T>());

        var semaphore = new SemaphoreSlim(maxConcurrentTasks);

        // Run the throttler on a separate thread.
        var t = Task.Run(() =>
            foreach (var item in enumerable)
                // Wait for the semaphore


        var taskList = new List<Task<Result_T>>();

        Parallel.ForEach(IterateUntilTrue(() => blockingQueue.IsCompleted), new ParallelOptions { MaxDegreeOfParallelism = maxDegreeOfParallelism },
        _ =>
            Enumerable_T item;

            if (blockingQueue.TryTake(out item, 100))
                    // Run the task
                    .ContinueWith(tsk =>
                            // For effect

                            // Release the semaphore

                            return tsk.Result;

        // Await all the tasks.
        return await Task.WhenAll(taskList);

    static IEnumerable<bool> IterateUntilTrue(Func<bool> condition)
        while (!condition()) yield return true;

The method utilizes BlockingCollection and SemaphoreSlim to make it work. The throttler is run on one thread, and all the async tasks are run on the other thread. To achieve parallelism, I added a maxDegreeOfParallelism parameter that’s passed to a Parallel.ForEach loop re-purposed as a while loop.

Bonus: To get around the problem in BlockingCollection where an exception is thrown in Take() when CompleteAdding() is called, I’m using the TryTake overload with a timeout. If I didn’t use the timeout in TryTake, it would defeat the purpose of using a BlockingCollection since TryTake won’t block. Is there a better way? Ideally, there would be a TakeAsync method.

Leave a Reply

Close Menu