C# 如何使用互斥锁

在C#中，使用互斥锁（Mutex）可以实现线程间的互斥访问，确保同一时间只有一个线程可以访问共享资源。下面是使用互斥锁的步骤：

1. 创建一个互斥锁对象：

   Mutex mutex = new Mutex();

2. 在需要保护的代码块前后分别调用`WaitOne()`和`ReleaseMutex()`方法：

   mutex.WaitOne(); // 等待获取互斥锁
   try
   {
       // 执行需要保护的代码
   }
   finally
   {
       mutex.ReleaseMutex(); // 释放互斥锁
   }

在上述代码中，`WaitOne()`方法会阻塞当前线程，直到获取到互斥锁为止。`ReleaseMutex()`方法用于释放互斥锁，允许其他线程获取锁并执行相应的代码。

使用互斥锁时需要注意以下几点：
- 互斥锁是进程内的同步对象，可以在不同线程间使用，但不能在不同进程间使用。
- 在使用互斥锁时，应确保在获取锁后及时释放锁，以免造成死锁。
- 可以使用`Mutex.WaitOne(TimeSpan)`方法设置等待超时时间，避免长时间等待。

相关问题

C#互斥锁

C#中的互斥锁是一种同步机制，用于保护共享资源的并发访问。当一个线程拥有互斥锁时，其他线程无法同时拥有该锁，只能等待该线程释放该锁后才能获得。这样可以防止多个线程同时访问共享资源，避免数据竞争和不可预测的行为。

在C#中，可以使用System.Threading命名空间中的Mutex类来创建互斥锁。下面是一个示例代码，演示了如何使用互斥锁来保护共享资源的访问：

using System;
using System.Threading;

public class Example
{
    private static Mutex mutex = new Mutex();  // 创建互斥锁对象

    public static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            Thread myThread = new Thread(new ThreadStart(MyThreadProc));
            myThread.Name = String.Format("Thread{0}", i + 1);
            myThread.Start();
        }
    }

    private static void MyThreadProc()
    {
        Console.WriteLine("{0} is waiting for the mutex", Thread.CurrentThread.Name);

        mutex.WaitOne();  // 等待互斥锁

        Console.WriteLine("{0} has entered the critical section", Thread.CurrentThread.Name);

        // 访问共享资源

        Console.WriteLine("{0} is leaving the critical section", Thread.CurrentThread.Name);

        mutex.ReleaseMutex();  // 释放互斥锁
    }
}

在上面的示例中，创建了一个互斥锁对象mutex，并在MyThreadProc方法中使用mutex.WaitOne()等待互斥锁，使用mutex.ReleaseMutex()释放互斥锁。这样可以保证只有一个线程可以进入“critical section”，避免了多个线程同时访问共享资源的问题。

C# 多线程多个互斥锁

在C#中，可以使用多个互斥锁来实现多线程的同步。互斥锁是一种同步机制，用于保护共享资源，一次只允许一个线程访问被锁定的代码块。下面是使用多个互斥锁的示例代码：

using System;
using System.Threading;

class Program
{
    static Mutex mutex1 = new Mutex();
    static Mutex mutex2 = new Mutex();

    static void Main()
    {
        // 创建两个线程
        Thread thread1 = new Thread(DoWork1);
        Thread thread2 = new Thread(DoWork2);

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

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

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }

    static void DoWork1()
    {
        Console.WriteLine("Thread 1 is waiting for mutex1...");
        mutex1.WaitOne();

        Console.WriteLine("Thread 1 acquired mutex1. Doing some work...");

        // 模拟耗时操作
        Thread.Sleep(2000);

        Console.WriteLine("Thread 1 is waiting for mutex2...");
        mutex2.WaitOne();

        Console.WriteLine("Thread 1 acquired mutex2. Continuing work...");

        // 执行一些其他操作

        // 释放互斥锁
        mutex2.ReleaseMutex();
        mutex1.ReleaseMutex();
    }

    static void DoWork2()
    {
        Console.WriteLine("Thread 2 is waiting for mutex2...");
        mutex2.WaitOne();

        Console.WriteLine("Thread 2 acquired mutex2. Doing some work...");

        // 模拟耗时操作
        Thread.Sleep(2000);

        Console.WriteLine("Thread 2 is waiting for mutex1...");
        mutex1.WaitOne();

        Console.WriteLine("Thread 2 acquired mutex1. Continuing work...");

        // 执行一些其他操作

        // 释放互斥锁
        mutex1.ReleaseMutex();
        mutex2.ReleaseMutex();
    }
}

在上面的示例中，我们创建了两个互斥锁 `mutex1` 和 `mutex2`，并且分别在 `DoWork1` 和 `DoWork2` 方法中使用了这两个互斥锁来保护共享资源。注意，在获取互斥锁之后，需要在适当的时候释放互斥锁，以便其他线程可以获取它们。

请注意，使用多个互斥锁可能会导致死锁问题，因此在设计多线程应用程序时需要小心处理锁的使用顺序和释放顺序，以避免死锁情况的发生。