什么是互斥？

使用私有锁对象的lock语句创建一个临界区.要求每个线程等到上一个完成.第一个线程将进入该部分并初始化实例.第二个线程将等待,进入该部分,并获取初始化的实例.

静态成员的任何类型的同步都可以类似地使用lock语句.

什么是互斥体？

互斥体(实际上,术语互斥是互斥的缩写)也称为自旋锁是最简单的同步工具,用于保护关键区域,从而防止竞争条件.这是一个线程必须在进入关键部分之前获得一个锁(在关键部分多线程共享一个公共变量,更新表,写一个文件等),它在离开临界区时释放锁.

什么是比赛条件？

当两个或多个线程可以访问共享数据并且他们尝试同时更改它时,会发生竞争条件.因为线程调度算法可以在任何时间在线程之间交换,所以您不知道线程将尝试访问共享数据的顺序.因此,数据变化的结果取决于线程调度算法,即两个线程都"竞相"访问/改变数据.

真人生活的例子:

当我在工作中进行激烈的讨论时,我会使用一只橡皮鸡,我会把它留在我的办公桌上.持鸡的人是唯一被允许说话的人.如果你不抓鸡,你就不会说话.你只能表明你想要鸡肉并等到你说话之前就得到它.讲完后,你可以把鸡还给主持人,主持人会把它交给下一个发言的人.这可以确保人们不会互相交谈,也有自己的谈话空间.

用Mutex替换鸡和有线程的人,你基本上有互斥的概念.

@Xetius

在C#中的用法:

此示例显示如何使用本地Mutex对象来同步对受保护资源的访问.因为每个调用线程在获取互斥锁的所有权之前都被阻塞,所以它必须调用ReleaseMutex方法来释放线程的所有权.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name);
        mut.WaitOne();

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

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

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

        // Release the Mutex.
        mut.ReleaseMutex();
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name);
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread2 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread3 is requesting the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
//       Thread3 has released the mutex
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       Thread2 has released the mutex