Thread doesn't terminate when main thread finishes

Question

I have a weird issue:

In my C# app, I am creating another thread, like so:

Thread printThread = new Thread(printWorker);

printThread.Name = "Logger MainThread";
printThread.IsBackground = true;
printThread.Start();

When my main thread finishes, this new thread just keeps on working, although it's marked as Background.

What could be the causes for this? This object is holding a Mutex object, not sure this may be the reason...

Any ideas anyone?

Here's the code from the printWorker method:

while (loggerIsActive)
{
    LogMessage log = LoggerQueue.Dequeue();

    if (log.message != null)
    {
        syncLogObj.WaitOne();
        lock (writerobj)
        {
            StreamWriter sw;

            if (!File.Exists(fName))
            {
                sw = File.CreateText(fName);
            }
            else
            {
                sw = new StreamWriter(fName, true);
            }

            using (sw)
            {
                if (log.message != "")
                {
                    if (log.message.EndsWith("\r\n"))
                    {
                        log.message =
                            log.message.Substring(0, log.message.Length - 2);
                    }

                    sw.WriteLine(string.Format("[{0}][{3}][{1}] | {2}",
                                               log.msgTime,
                                               log.level.ToString(),
                                               log.message,
                                               log.sender.ToString()));
                }

                sw.Flush();
                sw.Close();
            }
        }

        syncLogObj.ReleaseMutex();
    }

    Thread.Sleep(5);
}

Answer 1

Try this:

Start the app through VS and exit normally. The VS should stay in Debug mode as you described. Click on Pause button (Break all) and then go to Debug->Windows->Threads. Do you see your "Logger MainThread" in the list?

• If so, double-click it, it should lead you to the code line that the thread is currently executing. Step-debug from there and see why is it not terminating.
• If you don't see it try looking at other threads that have not terminated and try to find the problem.

Otherwise, with those kind of problems it's always useful to monitor the program state via System.Diagnostics.Debug.Print statements (you can see them printing in the VS output window).

Answer 2

kill it.

Not pretty. But this isn't TV. Read on:

1) Not sure you use are using it but it appears you should be locking loggerqueue before you queue(main pgm) or dequeue(thread).
2) No need to lock writerobj with just this setting. But really you should so you can safely kill the thread not during a write:

• main thread:
  • do everything
  • before close: -lock writerobj -printthread.abort
• worker thread:
  • add try catch to handle threadabort exception and just quit

If you're properly doing this, you shouldn't have to use Waits and mutexes. If you are using wait properly anyway you won't need the sleep.

General advice for this application: why not log on main thread? if your logging is that busy, log results will be pretty useless.

But there are rare cases where that might be wrong. Entonces......

General advice to have threads play nice for this problem:

• Main program
  • encapsulate logging (notably, quit flag, queue, and worker thread ref) in an object
  • 'global snobs?' Logging is a rare excuse to use singleton patter.
  • start worker thread in logger object via method
  • main thread always calls a single method on logger object to log error
  • That method locks the queue and adds to it.
  • Use Monitor/Pulse/Wait, no sleep; full examples abound; it is worth learning
    • because only this thread is hitting the file anyway, unless you have multiple processes, you don't need waitone/releasemutex.
  • That logging method monitor.pulses an object
  • That frees the worker thread's monitor.wait (which is what idles the CPU instead of sleep)
  • lock the queue, only inside the lock dequeue the object to local ref; nothing else.
  • Do your normal logging code and 'exit check' loop. Add
    • Your logic code could leave message unwritten if queue is full on quit:
    • change to exit check so you can do it without an extra lock of queue:
      • move declaration of queued object refernce above while; set it to nothing
      • change logic in while to 'loggerisactive or log != null'
  • when your main thread finishes, in your exit code:
    • set the quit flag
    • pulse the object you're using to wait incase it's not processing the queue
    • Thread will fall thru.

Answer 3

You have a lot of stuff going on that you're obviously not showing...

Exmaple: you have syncLogObj.WaitOne();, but we don't see where syncLogObj is being declared, or used elsewhere in your program.

Plus, you don't need it... get rid of the syncLogObj thing altogether (including the "ReleaseMutex" garbage)... you already have a lock (blah) { }, and that's all you need (from what code you have displayed).

It's likely that the main thread is NOT ending, likely because of this or some other object that is keeping it open.

So, simple instructions

1. Get rid of syncLogObj (because you already have the "lock")
2. Make sure you set loggerIsActive = false somewhere.

Edit: Even more details!

From what I see - you don't need the lock (writerobj) at all, because (I'm quite sure), you only seem to have one thread that is writing to the log.

The "lock" is only there if you have two or more threads that running that code (basically).

Answer 4

If printworker does not finish before your main thread is done, then main will die and your printworker thread will be killed by the OS. If you want main to wait for the thread you created, then you should call printThread.Join() in main. That will get main to wait on your thread.

When main finishes your program dies and your printThread will be destroyed by the OS, It will not keep running.

From here

Background threads are identical to foreground threads with one exception: a background thread does not keep the managed execution environment running. Once all foreground threads have been stopped in a managed process (where the .exe file is a managed assembly), the system stops all background threads and shuts down.

Answer 5

Tony the Tiger has the right idea but additional code needs to be added to kill the thread before the application closes.

printThread.Join(1000);
if(printThread!=null && printThread.IsAlive)
    printThread.Abort();

Answer 6

Thread.Abort();
Thread.Dispose();

That should do it if I'm not mistaken.