{"id":543,"date":"2011-05-10T09:00:00","date_gmt":"2011-05-10T09:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2011\/05\/10\/simultaneous-async-tasks-alan-berman\/"},"modified":"2024-07-05T12:39:48","modified_gmt":"2024-07-05T19:39:48","slug":"simultaneous-async-tasks-alan-berman","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/simultaneous-async-tasks-alan-berman\/","title":{"rendered":"Simultaneous Async Tasks (Alan Berman)"},"content":{"rendered":"

The new Async feature in the Visual Studio Async CTP (SP1 Refresh)<\/a> provides an elegantly simple technique to make code asynchronous.<\/p>\n

Our writing team uses an internal app that would benefit from asynchronous calls.  For each URL contained in the MSDN documentation that we publish, the app lists the title from the link, and the title parsed from HTML in the downloaded web page.  We use the app to verify that URL links are valid.<\/p>\n

The following example is a very simplified version of the relevant code, which does synchronous reads of multiple web pages.<\/p>\n

 <\/p>\n

Imports System.Net
Imports System.Threading.Tasks<\/span><\/p>\n

Module Module1
    Sub Main()
        Dim urls As List(Of String) = BuildURLs()<\/span><\/p>\n

        Dim startTime = Date.Now<\/span><\/p>\n

        GetWebPagesSynchronous(urls)
        ‘GetWebPagesAsync(urls).Wait()<\/span><\/p>\n

        Dim seconds = (Date.Now – startTime).TotalSeconds<\/span><\/p>\n

        Console.WriteLine()
        Console.WriteLine(“Ended in ” & seconds & ” seconds”)
        Console.ReadKey()
    End Sub<\/span><\/p>\n

    Private Sub GetWebPagesSynchronous(urls As List(Of String))
        Dim client As New WebClient<\/span><\/p>\n

        For Each url In urls
            Dim text = client.DownloadString(New Uri(url))
            Console.WriteLine(GetTitle(text))
        Next
    End Sub<\/span><\/p>\n

    Private Function GetTitle(input As String) As String
        Const startText = “<title>”
        Const endText = “<\/title>”<\/span><\/p>\n

        Dim startIndex = input.IndexOf(startText)
        If startIndex = -1 Then
            Return “not found”
        Else
            startIndex += startText.Length
            Dim endIndex = input.IndexOf(endText, startIndex)
            Dim result = input.Substring(startIndex, endIndex – startIndex)
            Return result.Trim()
        End If
    End Function<\/span><\/p>\n

    Private Function BuildURLs() As List(Of String)
        Return New List(Of String) From
            {
            “<\/span>http:\/\/www.microsoft.com”<\/span><\/a>,
            “<\/span>http:\/\/msdn.com”<\/span><\/a>
            }
    End Function
End Module
<\/span><\/p>\n

 <\/p>\n

The following method transforms the above example to use the Async feature.  Starting with the above example, change Main to call GetWebPagesAsync(urls).Wait() instead of GetWebPagesSynchronous(urls).<\/p>\n

In your project, add a reference to AsyncCtpLibrary.dll, which is in My DocumentsMicrosoft Visual Studio Async CTPSamples.<\/p>\n

 <\/p>\n

Private Async Function GetWebPagesAsync(urls As List(Of String)) As Task<\/span><\/p>\n

    Dim theTasks As New List(Of Task(Of String))<\/span><\/p>\n

    For Each url In urls
        Dim client As New WebClient()<\/span><\/p>\n

        Dim theTask As Task(Of String) =
            client.DownloadStringTaskAsync(New Uri(url))<\/span><\/p>\n

        theTasks.Add(theTask)
    Next<\/span><\/p>\n

    ‘ Wait until the tasks are done.<\/span><\/p>\n

    ‘ The Await statement causes execution to immediately return
    ‘ to the calling method, returning a new task. When all of the
    ‘ tasks complete, execution continues within this method.<\/span><\/p>\n

    ‘ TaskEx.WhenAll would normally be Task.WhenAll.
    ‘ It’s TaskEx.WhenAll in the CTP only.
    Await TaskEx.WhenAll(theTasks)<\/span><\/p>\n

    For Each theTask In theTasks
        Console.WriteLine(GetTitle(theTask.Result))
    Next
End Function<\/span><\/p>\n

 <\/p>\n

For each URL in the list, the DownloadStringTaskAsync method returns a Task object that is then stored in a generic List.  The code waits for completion of all of the tasks by using an Await statement and the Task.WhenAll method. The WhenAll method accepts an object that implements IEnumerable(T)<\/a>, including List(T)<\/a>.<\/p>\n

The code spins up all of these tasks without worrying about running out of resources from a language perspective.  I was inclined to write code to carefully throttle the calls to conserve resources, but was told that is unnecessary.<\/p>\n

On computer running Window\ns 7, at a randomly convenient time, I ran the above console apps five times synchronously and five times asynchronously, with 20 URLs and 100 URLs. For 20 URLs, the average time to complete was 7.2 seconds for synchronous and 3.2 seconds for Async.  For 100 URLs, the average was 39.5 seconds for synchronous, and 28.5 seconds for Async.  With 100 URLs on another day, the average was 39.9 seconds for synchronous, and 13.5 seconds for Async.  The results are specific to the conditions, and your results will vary.<\/p>\n

Note that the speedup in the Async example is almost entirely from the parallel processing, not the asynchronous processing.  The advantages of asynchrony are that it does not tie up multiple threads, and that it does not tie up the user interface thread.<\/p>\n

Cancellation<\/strong><\/p>\n

The following example adds cancellation<\/a>.  To actually cancel the operation, modify the code to change cancelIt = False to cancelIt = True, and change the Thread.Sleep call to specify the milliseconds before cancellation.<\/p>\n

This code creates a CancellationTokenSource<\/a> that contains a CancellationToken<\/a>. The same cancellation token is passed to every call to DownloadStringTaskAsync. The CancellationTokenSource is also used to invoke cancellation.<\/p>\n

 <\/p>\n

Imports System.Net
Imports System.Threading
Imports System.Threading.Tasks<\/span><\/p>\n

Module Module1
    Sub Main()
        Dim urls As List(Of String) = BuildURLs()<\/span><\/p>\n

        Dim startTime = Date.Now<\/span><\/p>\n

        ProcessAsyncCancellable(urls)<\/span><\/p>\n

        Dim seconds = (Date.Now – startTime).TotalSeconds<\/span><\/p>\n

        Console.WriteLine()
        Console.WriteLine(“Ended in ” & seconds & ” seconds”)
        Console.ReadKey()
    End Sub<\/span><\/p>\n

    Private Sub ProcessAsyncCancellable(urls As List(Of String))
        Dim cts As New CancellationTokenSource()<\/span><\/p>\n

        cts.Token.Register(Sub() Console.WriteLine(“cancelling”))<\/span><\/p>\n

        Dim theTask As Task = GetWebPagesAsync(urls, cts)<\/span><\/p>\n

        ‘ To cancel midstream, set cancelIt to True.
        Dim cancelIt = False
        If cancelIt Then
            ‘ Set the milliseconds before cancelling.
            Thread.Sleep(2000)
            cts.Cancel()
        Else
            theTask.Wait()
        End If
    End Sub<\/span><\/p>\n

    Private Async Function GetWebPagesAsync( _
    urls As List(Of String),
    cts As CancellationTokenSource) As Task<\/span><\/p>\n

        Dim theTasks As New List(Of Task(Of String))<\/span><\/p>\n

        For Each webAddress In urls
            Dim client As New WebClient()<\/span><\/p>\n

            Dim theTask As Task(Of String) =
                client.DownloadStringTaskAsync(New Uri(webAddress), cts.Token)<\/span><\/p>\n

            theTasks.Add(theTask)
        Next<\/span><\/p>\n

        Await TaskEx.WhenAll(theTasks)<\/span><\/p>\n

        For Each theTask In theTasks
            Console.WriteLine(GetTitle(theTask.Result))
        Next
    End Function<\/span><\/p>\n

    Private Function BuildURLs() As List(Of String)
        Return New List(Of String) From
            {
            “<\/span>http:\/\/www.microsoft.com”<\/span><\/a>,
            “<\/span>http:\/\/msdn.com”<\/span><\/a>
            }
    End Function
    Private Function GetTitle(input As String) As String
        Const startText = “<title>”
        Const endText = “<\/title>”<\/span><\/p>\n

        Dim startIndex = input.IndexOf(startText)
        If startIndex = -1 Then
            Return “not found”
        Else
            startIndex += startText.Length
            Dim endIndex = input.IndexOf(endText, startIndex)
            Dim result = input.Substring(startIndex, endIndex – startIndex)
    &nbs\np;       Return result.Trim()
        End If
    End Function
End Module
<\/span><\/p>\n

 <\/p>\n

The above example displays all of the titles only when all of the tasks are complete. If you want to see the results before cancellation, you can replace GetWebPagesAsync with the following:<\/p>\n

 <\/p>\n

Private Async Function GetWebPagesAsync( _
urls As List(Of String),
cts As CancellationTokenSource) As Task<\/span><\/p>\n

    For Each webAddress In urls
        Dim client As New WebClient()<\/span><\/p>\n

        Dim theTask As Task(Of String) =
            client.DownloadStringTaskAsync(New Uri(webAddress), cts.Token)<\/span><\/p>\n

        Await theTask
        Console.WriteLine(GetTitle(theTask.Result))
    Next
End Function<\/span><\/p>\n

 <\/p>\n

Thanks to Anthony Green, Alex Turner, Lucian Wischik, Mick Alberts, and Thomas Petchel for providing tech review.<\/p>\n

 <\/p>\n

Resources<\/strong><\/p>\n