Why cancelling 6 WebRequest using Task.Start takes longer that Thread.Start

I have custom asynchronous WebRequest class that I am testing to find out how fast the request will be cancelled and found some odd results, that starting 6 WebRequests with TPL and cancelling them right away takes 25 sec, but when I used just regular background threads it took only 5 sec.

Update: Running them without cancelling takes with Task.Start 9 sec and Thread.Start 3 sec accordingly.

Imports System.Net
Imports System.Threading
Imports System.IO
Imports System.Threading.Tasks

Module Module2

Dim closeEvent As New ManualResetEvent(False)
Dim sw As System.Diagnostics.Stopwatch

' first domain is invalid
Dim urls() As String = {
    "http://www.jbihgcgfxfdxdwewloevedfhvcdfb.com", 
    "http://www.hanselman.com/blog/",
    "http://www.stackoverflow.com/questions/",
    "http://www.finderscope.net",
    "http://msdn.microsoft.com/en-us/library/az24scfc.aspx",
    "http://www.developerfusion.com/tools/convert/csharp-to-vb/"
}

Sub Test1()
    sw = System.Diagnostics.Stopwatch.StartNew
    Dim action As Action(Of Object) = Sub(url As String)
                                          Dim wReq As WebRequest = WebRequest.Create(url)
                                          RunWebStreamAsync(wReq, closeEvent)
                                          Console.WriteLine("done in {0} ms : {1}", sw.ElapsedMilliseconds, Left(url, 50))
                                      End Sub
    Try
        '' Cosntruct a started task
        Dim t(5) As task
        For i As Integer = 0 to 5
            t(i) = New Task(action, urls(i)) 
        Next
        For Each tsk In t
            tsk.Start()
        Next
        closeEvent.Set()
        Task.WaitAll(t)
    Catch ex As Exception
        Console.WriteLine(ex.Message)
    End Try
    Console.WriteLine("total in {0} ms", sw.ElapsedMilliseconds)
End Sub

Dim WaitCount As Integer = 6
Sub Test2()
    sw = System.Diagnostics.Stopwatch.StartNew
    For i As Integer = 0 to 5
        StartThread(urls(i))
    Next
    closeEvent.Set()
    Do While WaitCount > 0
        Thread.Sleep(1000)
    Loop
    Console.WriteLine("total in {0} ms", sw.ElapsedMilliseconds)
End Sub

Private Sub StartThread(ByVal url As String)
    Dim trd As Thread = New Thread(AddressOf ThreadTask)
    trd.IsBackground = True
    trd.Start(url)
End Sub

Private Sub ThreadTask(ByVal arg As Object)
    Dim url As String = arg
    Try
        Dim wReq As WebRequest = WebRequest.Create(url)
        RunWebStreamAsync(wReq, closeEvent)
    Catch 
    End Try
    Console.WriteLine("done in {0} ms : {1}", sw.ElapsedMilliseconds, Left(url, 50))
    Interlocked.Decrement(WaitCount)
End Sub

Public Sub RunWebStreamAsync(ByVal wr As WebRequest, ByVal CloseTask As ManualResetEvent)
    Dim hwra As New MyWebRequest
    hwra.LoadAsync(wr)
    Do 开发者_运维技巧While hwra.AsyncOperationInProgress
        If CloseTask.WaitOne(1000) = True Then
            If hwra.CancellationPending = False Then
                hwra.CancellationPending = True
                wr.Abort()
            End If
        Else
            Thread.Sleep(100)
        End If
    Loop
End Sub

Class MyWebRequest
    Public Property CancellationPending As Boolean
    Public Property AsyncOperationInProgress As Boolean

    Public Sub LoadAsync(ByVal req As WebRequest)
        AsyncOperationInProgress = True
        ' Invoke BeginGetResponse on a threadpool thread, as it has
        ' unpredictable latency
        Dim bgrd = (New WaitCallback(AddressOf Me.BeginGetResponseDelegate))
        bgrd.BeginInvoke(req, Nothing, Nothing)
    End Sub

    ' Solely for calling BeginGetResponse itself asynchronously. 
    Private Sub BeginGetResponseDelegate(ByVal arg As Object)
        If CancellationPending Then
            PostCompleted(Nothing, True)
        Else
            Dim req As WebRequest = DirectCast(arg, WebRequest)
            req.BeginGetResponse(New AsyncCallback(AddressOf GetResponseCallback), req)
        End If
    End Sub

    Private Sub PostCompleted(ByVal p1 As Object, ByVal p2 As Boolean)
        AsyncOperationInProgress = False
        ' do something
    End Sub

    Private Sub GetResponseCallback(ByVal result As IAsyncResult)
        If CancellationPending Then
            PostCompleted(Nothing, True)
        Else
            Try
                ' Continue on with asynchronous reading.
                PostCompleted(Nothing, True)
            Catch ex As Exception
                ' Since this is on a non-UI thread, we catch any exceptions and
                ' pass them back as data to the UI-thread. 
                PostCompleted(ex, False)
            End Try
        End If
    End Sub
End Class
End Module

The difference is due to the fact that your Tasks are only started when the Task scheduler decides it should start them - while the Threads are all started immediately by your code.

In the case where you cancel immediately, this code below is a busy loop - when CloseTask is set, then this loop contains no Sleep-time:

  Do While hwra.AsyncOperationInProgress
        If CloseTask.WaitOne(1000) = True Then
            If hwra.CancellationPending = False Then
                hwra.CancellationPending = True
                wr.Abort()
            End If
        Else
            Thread.Sleep(100)
        End If
    Loop

Since this code loops taking lots of CPU cycles, then this will discourage the Task scheduler from starting new Tasks - so that's why the tasks get executed in series (hence why your test takes so long).

To improve perfromance, some ideas you could try are:

• at a trivial level, put a Sleep in that busy loop.
• check if the CloseTask event is set before calling hwra.LoadAsync(wr)
• ensure that WebRequest.Abort is called when CloseTask is set (this is hinted at in your code sample, but it's not complete)
• rearchitect so that the web requests respond back using completed events instead of using threads to busy poll the AsyncOperationInProgress flag - if you are using a thread to monitor each asyncIO, then you may as well just use Sync IO.