Common thread synchronization problems and solutions in C#

Common thread synchronization problems and solutions in C

#Introduction:
In multi-threaded programming, thread synchronization is a key concept. When multiple threads access shared resources at the same time, problems such as data inconsistency or race conditions may occur. This article will introduce common thread synchronization problems in C# and provide corresponding solutions and sample codes.

1. Incorrect data sharing
When multiple threads access the same shared resource at the same time, data inconsistency may result. A common solution to this problem is to use a mutex.

Sample code:

using System;
using System.Threading;

class Program
{
    static int count = 0;
    static Mutex mutex = new Mutex();

    static void Main()
    {
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++)
        {
            threads[i] = new Thread(Increment);
            threads[i].Start();
        }

        foreach (Thread t in threads)
        {
            t.Join();
        }

        Console.WriteLine("Count: " + count);
    }

    static void Increment()
    {
        mutex.WaitOne();
        count++;
        mutex.ReleaseMutex();
    }
}

In the above example, we created a global variable count, and then created 5 threads to increment the count. Using Mutex ensures that only one thread can access count at a time and avoids data inconsistency problems.

2. Race condition
A race condition occurs when multiple threads try to modify a shared resource at the same time. To avoid race conditions, we can use the Monitor class or lock statement to protect shared resources.

Sample code:

using System;
using System.Threading;

class Program
{
    static int count = 0;

    static void Main()
    {
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++)
        {
            threads[i] = new Thread(Increment);
            threads[i].Start();
        }

        foreach (Thread t in threads)
        {
            t.Join();
        }

        Console.WriteLine("Count: " + count);
    }

    static void Increment()
    {
        lock (typeof(Program))
        {
            count++;
        }
    }
}

In the above example, we use the lock statement to protect count. The lock statement automatically acquires a monitor. When a thread accesses a shared resource, other threads will be blocked until the current thread releases the lock.

3. Semaphore
Semaphore is a synchronization tool used to control thread access to resources. Through semaphores, we can limit the number of concurrent accesses by threads to ensure correct access to resources.

Sample code:

using System;
using System.Threading;

class Program
{
    static int count = 0;
    static Semaphore semaphore = new Semaphore(2, 2);

    static void Main()
    {
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++)
        {
            threads[i] = new Thread(Increment);
            threads[i].Start();
        }

        foreach (Thread t in threads)
        {
            t.Join();
        }

        Console.WriteLine("Count: " + count);
    }

    static void Increment()
    {
        semaphore.WaitOne();
        count++;
        semaphore.Release();
    }
}

In the above example, we created a semaphore with an initial value of 2, indicating that 2 threads are allowed to access shared resources at the same time. When all threads have finished executing, we get the correct count value.

Conclusion:
With appropriate thread synchronization mechanism, we can avoid common problems in C# multi-threaded programming and ensure that multiple threads can correctly access shared resources. This article introduces sample code using Mutex, lock statement and Semaphore for readers' reference. When writing a multi-threaded application, you need to choose an appropriate synchronization method based on actual needs to ensure the correctness and performance of the program.

The above is the detailed content of Common thread synchronization problems and solutions in C#. For more information, please follow other related articles on the PHP Chinese website!