How To Debug Multithreaded Programs In C#

Introduction

This article is mainly focused on the process of multithread debugging. We have used thread in C# many times, and we usually ignore the thread debugging process, usually, we only check the coding part and trace the error. As we know, threading problems are difficult to handle. Like we have an immutable application that handles the many mutable objects (single thread). If we can see the problem of deadlocks, usually a deadlock is the easiest problem to debug. Let's suppose we get a deadlock error in a stack trace. We can easily fix our code and prevent that error. With deadlocks, the problem is the same locks in different orders. Now let's see some other aspects of threads.

Race conditions in C#

A race condition is a difficult problem to debug and also a harder task to find from our code. Some other issues make our application cumbersome to handle.

Perhaps this article can help you if you are unfamiliar with the new thread window. In Visual Studio 2012, there is an improvised Thread window. In that Thread window, we can debug our multithreaded applications easily. So before we start, just try to work through the following topics that we will cover.

• What threads are?
• Working with multithreaded console applications.
• Open the Thread Window
• Working with the Thread Window

What is a thread in C#?

A thread is the smallest sequence of programmed instructions, or we can say that a thread is a small set of executable instructions that can be used to isolate a task from a process. And in some cases, we can say that a thread is a component of a process.

We can use threads in C# using the System. Threading namespace.

Working with multiple threads in console applications

In this section, we will see a simple console application where I created 2 threads.

using System;
using System.Threading;
namespace DebugThread
{
    class Program
    {
        static int i = 0;
        static void Main(string[] args)
        {
            Thread T1 = new Thread(MyMethod);
            Thread T2 = new Thread(MyMethod);
            T1.Start();
            T2.Start();
            Console.Read();
        }
        static void MyMethod()
        {
            for (int j = 0; j < 10; j++) // Changed the loop variable name to avoid conflict
            {
                i++; // Note: This will increment the shared 'i' variable
                Thread.Sleep(5000);
            }
        }
    }
}

Open the Thread Window in C#

Step 1. Insert a Breakpoint in the code.

static void MyMethod()
{
    for (int i = 0; i < 10; i++)
    {
        i++; // Increment 'i'
        Thread.Sleep(5000); // Sleep for 5000 milliseconds (5 seconds)
    }
}

Step 2. Run our application (press F5).

Step 3. Click on the Debug menu and choose the Windows option, then select Threads, as shown in the following image.

Working with Thread Window in C#

Now let's have a look at the Thread window.

As in the preceding image, we can see the thread having no name. So, let's assign the name of the thread.

static void Main(string[] args)
{
    Thread T1 = new Thread(MyMethod);
    T1.Name = "T1";
    Thread T2 = new Thread(MyMethod);
    T2.Name = "T2";
    T1.Start();
    T2.Start();
    Console.Read();
}

Now we can see the thread name in the Thread Window.

Flagging and Unflagging Thread in C#

• Go to the Debugging Location toolbar, click the Thread list, and see how many threads appear in the list.
• Go back to the source window and right-click the Thread marker again.
• On the shortcut menu, point to Flag and then click the thread name and ID number.

To unflag threads in C#

On the Threads window, right-click the line corresponding to the flagged thread. A shortcut menu is displayed. It has options to Unflag and Unflag All.

To unflag the thread, click Unflag. Or click the Red flag icon.

To freeze and Thaw threads in C#

Freezing a thread will suspend its execution in the debugging process. We can say Freeze has suspended the process and Thawing resumes the process. By Freezing and Thawing threads (suspending and resuming), we can have control of the threads running during the debugging process. It helps us when we are solving bugs related to concurrency.

In the Threads window, right-click any thread and then click Freeze.

Look at the active thread column. The pair of vertical bars now appear there.

Right-click the frozen thread and then click Thaw.

The active thread column and the Suspend column change.