After adding multi threading to my app, VS2010 will not remove file handle after stopping debugging

Question

today I've added multi threading to a windows forms application. On my UI thread I'm starting a thread via new Thread() {...}).Start(); Which itself will call a Method which uses ThreadPool.QueueUserWorkItem(). After the Method is called the thread will wait on a queue until a specific item is returned and the thread exits:

new Thread(o =>
        {
            s.SimulateChanges();

            Boolean run = true;

            while (run)
            {
                SimulationResult sr = queue.WaitDequeue();

                //EOF is a static property which will be returned 
                //if the queue is at its end so I can break the while loop
                if (SimulationResult.EOF.Equals(sr))
                {
                    run = false;
                    continue;
                }

                this.simulationProgressBar.BeginInvoke((Action)delegate()
                {
                    if (sr.IsDummy && this.simulationProgressBar.Value < this.simulationProgressBar.Maximum)
                    {
                        /*...*/
                    }
                    else
                    {
                        this.resultListView.AddObject(sr);
                    }
                });
            }

            this.simulationProgressBar.BeginInvoke((Action)delegate()
            {
                this.ToggleSimulationControls(true);
            });
        }).Start();

And that is the code of the method called:

public void SimulateChanges()
{
    ThreadPool.QueueUserWorkItem(o =>
        {
            foreach (IColElem elem in collection.AsEnumerable())
            {

                /*lot of code*/

                queue.Enqueue(new SimulationResult() { IsDummy = true });

            }
            log.Debug("Finished!");

            queue.Enqueue(SimulationResult.EOF);

        });
}

My Queue is a self written class allowing a thread to wait on dequeue until an object ins enqueued.

Everything is working fine, except that if I stop debugging (using stop debugging or simply closing the application) I can't rebuild my application as VS2010 doesn't remove the file handle. I believe it has something to do with my threads not exiting correctly. Is their any way I can assure this?

Thanks for any advice :-)

Answer 1

Hard to explain all aspects of the question. But you are making a pretty common mistake, often made by programmers when they first start using threads. You are not making sure that the thread stops running when the user closes the main window. It is an easy mistake to make, the UI thread takes care of a lot of grunt work. Including automatically terminating when the main window of your app is closed by the user. So at least part of your problem is that you did manage to close the main window. But didn't actually terminate the process. Building cannot work, your program's EXE is still in use.

Properly shutting down a thread can be very difficult, given that the user will close the window regardless of what that thread is doing. It could be catatonic, buried deep inside an operating system call and waiting for it to complete. Tough to ask it to quit when it isn't executing code.

There is a very simple solution, at least good enough to keep going with your project or solve half the problem you have. You can mark the thread as "kill automatically at program termination" and the CLR will take care of it. Use the IsBackground property, like this:

var t = new Thread(o =>
        {
           // Lotsa code
        });
t.IsBackground = true;
t.Start();

But do keep in mind that there's nothing graceful about that kind of kill. If you are writing a file or talking to a server then that's going to cause a partially written file or a very confused server. Otherwise not different from killing the program with task manager.