C# 编程指南：线程同步和互斥

文章

C# 编程指南：线程同步和互斥

在C#中，线程同步和互斥是为了确保多个线程安全地访问共享资源而采取的一种机制。

部分

使用锁（lock）实现线程同步

•

锁是一种基本的线程同步机制，它用于保护共享资源，确保一次只有一个线程可以访问该资源。

•

使用lock语句，将需要同步的代码块包裹在lock语句中，并传递一个对象作为锁。

•

同一时刻只有一个线程能够获得锁，其他线程必须等待锁被释放。

// 使用锁（lock）实现线程同步的示例代码

class Counter
{
    private int count = 0;
    private object lockObject = new object();

    public void Increment()
    {
        lock (lockObject)
        {
            count++;
        }
    }

    public void Decrement()
    {
        lock (lockObject)
        {
            count--;
        }
    }

    public int GetCount()
    {
        lock (lockObject)
        {
            return count;
        }
    }
}

// 创建Counter对象
Counter counter = new Counter();

// 创建多个线程对共享资源进行操作
Thread thread1 = new Thread(() =>
{
    for (int i = 0; i < 10000; i++)
    {
        counter.Increment();
    }
});

Thread thread2 = new Thread(() =>
{
    for (int i = 0; i < 10000; i++)
    {
        counter.Decrement();
    }
});

// 启动线程
thread1.Start();
thread2.Start();

// 等待线程执行完毕
thread1.Join();
thread2.Join();

// 输出最终结果
Console.WriteLine(counter.GetCount()); // 输出: 0

在以上示例中，定义了一个Counter类，该类具有增加（Increment）、减少（Decrement）和获取计数值（GetCount）的方法。使用lock语句将需要同步的代码块包裹在lock语句中，并传递一个对象（lockObject）作为锁。多个线程对Counter对象进行操作时，通过获取锁来保证线程安全。

部分

使用互斥量（Mutex）实现线程互斥

•

互斥量是一种系统级的同步对象，用于保护共享资源，确保一次只有一个线程可以访问该资源。

•

使用Mutex类，创建一个互斥量实例，并使用WaitOne方法获取互斥量的所有权，使用ReleaseMutex方法释放互斥量。

// 使用互斥量（Mutex）实现线程互斥的示例代码

class Counter
{
    private int count = 0;
    private Mutex mutex = new Mutex();

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

    public void Decrement()
    {
        mutex.WaitOne();
        count--;
        mutex.ReleaseMutex();
    }

    public int GetCount()
    {
        mutex.WaitOne();
        int value = count;
        mutex.ReleaseMutex();
        return value;
    }
}

// 创建Counter对象
Counter counter = new Counter();

// 创建多个线程对共享资源进行操作
Thread thread1 = new Thread(() =>
{
    for (int i = 0; i < 10000; i++)
    {
        counter.Increment();
    }
});

Thread thread2 = new Thread(() =>
{
    for (int i = 0; i < 10000; i++)
    {
        counter.Decrement();
    }
});

// 启动线程
thread1.Start();
thread2.Start();

// 等待线程执行完毕
thread1.Join();
thread2.Join();

// 输出最终结果
Console.WriteLine(counter.GetCount()); // 输出: 0

在以上示例中，使用Mutex类创建了一个互斥量实例，并通过WaitOne方法获取互斥量的所有权，使用ReleaseMutex方法释放互斥量。通过互斥量的使用，确保一次只有一个线程可以对Counter对象进行操作，从而实现线程互斥。

C# 编程指南

1.
使用锁（lock）实现线程同步
2.
使用互斥量（Mutex）实现线程互斥