当我在工作中进行激烈的讨论时，我会使用一只橡胶鸡，我将它放在我的办公桌上以备不时之需。拿着鸡的人是唯一可以说话的人。如果你不拿着鸡，你就不能说话。你只能表示你想要鸡肉，等到你拿到鸡后再说话。一旦你说完，你可以把鸡交还给主持人，主持人将把它交给下一个发言的人。这确保了人们不会互相交谈，并且也有自己的交谈空间。
用互斥锁替换鸡，用线程替换人，你基本上就有了互斥锁的概念。
当然，没有橡胶互斥体这样的东西。只有橡胶鸡。我的猫曾经有一只橡胶老鼠，但它们吃了。
当然，在你使用橡皮鸡之前，你需要先问问自己，你是否真的需要 5 个人在一个房间里，一个人在房间里独自完成所有工作会不会更容易。实际上，这只是扩展类比，但你明白了。

互斥锁是一个穆特平时前任包容性标志。它充当一段代码的看门人，允许一个线程进入并阻止对所有其他线程的访问。这确保了被控制的代码一次只会被一个线程命中。完成后一定要释放互斥锁。 🙂

穆特华尔前任包含。这是关于它的维基百科条目。
互斥锁的目的是同步两个线程。当您有两个线程尝试访问单个资源时，一般模式是让第一个代码块尝试访问以在输入代码之前设置互斥锁。当第二个代码块尝试访问时，它看到互斥锁已设置并等待直到第一个代码块完成（并取消设置互斥锁），然后继续。
显然，如何实现这一点的具体细节因编程语言而异。

当您有一个多线程应用程序时，不同的线程有时会共享一个公共资源，例如变量或类似资源。此共享源通常无法同时访问，因此需要一个构造来确保一次只有一个线程在使用该资源。
这个概念称为“互斥”（简称 Mutex），是一种确保在该区域内只允许一个线程使用该资源等的方法。
如何使用它们是特定于语言的，但通常（如果不总是）基于操作系统互斥锁。
由于范式，某些语言不需要这种结构，例如函数式编程（Haskell、ML 就是很好的例子）。

什么是互斥体?
互斥锁（实际上，术语互斥锁是互斥的缩写）也称为自旋锁，是最简单的同步工具，用于保护关键区域，从而防止竞争条件。即一个线程在进入临界区之前必须获得一个锁（在临界区中，多个线程共享一个公共变量，更新表，写入文件等），当它离开临界区时释放锁。
什么是比赛条件?
当两个或多个线程可以访问共享数据并且它们尝试同时更改它时，就会出现竞争条件。因为线程调度算法可以随时在线程之间交换，所以你不知道线程尝试访问共享数据的顺序。因此，数据更改的结果取决于线程调度算法，即两个线程都在“竞相”访问/更改数据。
现实生活中的例子：

当我在工作中进行激烈的讨论时，我会使用一只橡胶鸡，我将它放在我的办公桌上以备不时之需。拿着鸡的人是唯一可以说话的人。如果你不拿着鸡，你就不能说话。你只能表示你想要鸡肉，等到你拿到鸡后再说话。一旦你说完，你可以把鸡交还给主持人，主持人将把它交给下一个发言的人。这确保了人们不会互相交谈，并且也有自己的交谈空间。
用互斥锁替换鸡，用线程替换人，你基本上就有了互斥锁的概念。
@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

MSDN 参考互斥体