compilation debug = false causes ASP.NET Threading Issue

Question

I have a web application that uses threading that runs fine when compilation debug is set to true however as soon as it is set to false the page causes a spike in CPU and never loads.

I created a very simplified version of the code in order to test this issue which is below.

EDIT: Note that the aim of the Do While JobFinished < 1 Loop is to keep the page from loading until all the threads have completed so I can display the result of the calculation within the thread to the user. This doesn't seem to be a problem when compilation debug is set to true.

All help much appreciated.

Imports System.Xml
Imports System.IO
Imports System.Data.OleDb
Imports System.Data.SqlClient
Imports System.Data
Imports System.Math
Imports System.Threading

Partial Class _Default

    Inherits System.Web.UI.Page

    Protected MyThread As Thread
    Protected WithEvents myRequest As engineThread
    Protected JobFinished As Integer = 0

    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load

        ltMessage.Text = "<root>"

        myRequest = New engineThread()
        MyThread = New Thread(AddressOf myRequest.callEngine)
        MyThread.Start()

        Do While JobFinished < 1
        Loop

        ltMessage.Text &= "</root>"

    End Sub

    Public Sub engineHandler1() Handles myRequest.ThreadComplete

        ltMessage.Text &= "It Works!"
        JobFinished = JobFinished + 1

    End Sub

    Public Class engineThread

        Public Event ThreadComplete()

        Public Sub callEngine()

            RaiseEvent ThreadComplete()

        End Sub

    End Class

End Class

My web.config is simply as follows

<configuration>
    <system.web>      
      <compilation debug="false" strict="false" explicit="true" targetFramework="4.0" />
      <httpRuntime targetFramework="4.0" executionTimeout="600" />
    </system.web>
</configuration>

Answer 1

This...

Do While JobFinished < 1
Loop

Is awful. It means one core will spin at full speed for no reason burning cycles.

Create an Event to signal when the JobFinished count changes...

Dim DoneEvent As New AutoResetEvent(False)

Do While JobFinished < 1
    DoneEvent.WaitOne(1000)
Loop

Then for in the worker...

myRequest = New engineThread()
MyThread = New Thread(Sub() 
                          myRequest.callEngine()
                          DoneEvent.Set()
                      End Sub)
MyThread.Start()

Also, there's no reason to use a thread here - you're creating a new thread, using it, waiting for it to finish (inefficiently) and then carrying on. Since you're blocking the original thread anyway, why not just use it for the job at hand?

Answer 2

Do While JobFinished < 1
Loop

Is not a great idea - that will waste as much CPU as one thread can. You can wait for your thread to end with the Thread.Join() method.

As to the precise cause of the problem, I suspect that in release mode, your threadComplete is never executing. Replace that infinite loop with a Join() and get rid of the the threadcomplete event and see if that solves your problem.

As an aside, the correct way to signal between threads would be a ManualResetEvent or AutoResetEvent object, not a bool variable.

Answer 3

JobFinished = JobFinished + 1
...
Do While JobFinished < 1
    Loop

This is not thread safe code. Irrelevant of compile settings. JobFinishes must be volatile (of which VB has no knowledge, so use MemoryBarier) and the +1 must be interlocked. Right now your code will likely miss updates and cause an infinite loop (which is exactly what you see).

I can guarantee you that whatever you're trying to do, it can be done without threads. The code you posted shows serious gaps in understanding MT. You'll get burned a lot before you'll walk. Did you go over Multithreading in Visual Basic? For example, the code you're showing here should never be written using a loop. This is exactly what Events are for, after all. Read Advanced Synchronization Techniques.

Answer 4

The other posters give the right way to solve this problem - block page_load using a lock such as an AutoResetEvent.

Talking to the direct problem with the question: why does turning off debug break the code? When you turn off debug, you're likely turning on optimizations.

The loop, as written, is most likely optimized to an infinite loop. The loop condition variable is never modified within the scope of the loop, and since no effort is made to use any sort of memory barrier, the compiler has full right to expect that the value will never change. The compiler is free to optimize that loop to an infinite loop because you are relying on undefined behavior.

Specifically, the compiler probably optimizes to something that would look like the following:

If JobFinished < 1 Then
     Do While True
     Loop
End If

Or in C#:

if ( JobFinished < 1 ) {
     while(true) {}
}

At the very least, you should mark the variable as volatile, however, you cannot do that in VB.

Instead, use functions that enforce memory barrier semantics - Thread.VolatileRead() and Thread.VolatileWrite():

In page_load:

Do While Thread.VolatileRead( ByRef JobFinished ) < 1 Then 
Loop

In engineHandler1

Thread.VolatileWrite( ByRef JobFinished, JobFinished + 1 )

That said, this is still an awful way to solve your problem. I only provide this answer so that you can understand the original underlying problem.