How to limit the amount of concurrent async I/O operations?

by

You can definitely do this in the latest versions of async for .NET, using .NET 4.5 Beta. The previous post from ‘usr’ points to a good article written by Stephen Toub, but the less announced news is that the async semaphore actually made it into the Beta release of .NET 4.5

If you look at our beloved SemaphoreSlim class (which you should be using since it’s more performant than the original Semaphore), it now boasts the WaitAsync(...) series of overloads, with all of the expected arguments – timeout intervals, cancellation tokens, all of your usual scheduling friends 🙂

Stephen’s also written a more recent blog post about the new .NET 4.5 goodies that came out with beta see What’s New for Parallelism in .NET 4.5 Beta.

Last, here’s some sample code about how to use SemaphoreSlim for async method throttling:

public async Task MyOuterMethod()
{
    // let's say there is a list of 1000+ URLs
    var urls = { "http://google.com", "http://yahoo.com", ... };

    // now let's send HTTP requests to each of these URLs in parallel
    var allTasks = new List<Task>();
    var throttler = new SemaphoreSlim(initialCount: 20);
    foreach (var url in urls)
    {
        // do an async wait until we can schedule again
        await throttler.WaitAsync();

        // using Task.Run(...) to run the lambda in its own parallel
        // flow on the threadpool
        allTasks.Add(
            Task.Run(async () =>
            {
                try
                {
                    var client = new HttpClient();
                    var html = await client.GetStringAsync(url);
                }
                finally
                {
                    throttler.Release();
                }
            }));
    }

    // won't get here until all urls have been put into tasks
    await Task.WhenAll(allTasks);

    // won't get here until all tasks have completed in some way
    // (either success or exception)
}

Last, but probably a worthy mention is a solution that uses TPL-based scheduling. You can create delegate-bound tasks on the TPL that have not yet been started, and allow for a custom task scheduler to limit the concurrency. In fact, there’s an MSDN sample for it here:

See also TaskScheduler .

More Related Contents:

  1. WaitAll vs WhenAll
  2. Catch an exception thrown by an async void method
  3. Running multiple async tasks and waiting for them all to complete
  4. Calling async method synchronously
  5. Why does this async action hang when I try and access the Result property of my Task?
  6. Best way in .NET to manage queue of tasks on a separate (single) thread
  7. Task sequencing and re-entracy
  8. Enforce an async method to be called once
  9. Async/Await – is it *concurrent*?
  10. Process files concurrently and asynchronously
  11. Executing tasks in parallel
  12. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  13. A pattern for self-cancelling and restarting task
  14. What is the correct way to cancel an async operation that doesn’t accept a CancellationToken?
  15. ForEachAsync with Result
  16. Converting async/await to Task.ContinueWith
  17. How to throttle multiple asynchronous tasks?
  18. Synchronous implementation of interface that returns Task
  19. How to implement Task.WhenAny() with a predicate
  20. Calling TaskCompletionSource.SetResult in a non blocking manner
  21. What is the difference between asynchronous programming and multithreading?
  22. TAP global exception handler
  23. Using async without await
  24. Best way to convert callback-based async method to awaitable task
  25. ConfigureAwait pushes the continuation to a pool thread
  26. How can I prevent synchronous continuations on a Task?
  27. Horrible performance using SqlCommand Async methods with large data
  28. Await vs Task.Result in an Async Method [duplicate]
  29. Async and Await with For Loop [duplicate]
  30. When is the best place to use Task.Result instead of awaiting Task

Leave a Comment