What is a Semaphore in .NET, and how does it differ from a Mutex?

1. Counting semantics, step by step

new Semaphore(2, 2)          count = 2
T1 WaitOne                   count = 1
T2 WaitOne                   count = 0
T3 WaitOne                   blocks
T1 Release -> returns 0      count = 1 -> T3 wakes, count = 0
T2 Release -> returns 0      count = 1
T3 Release -> returns 1      count = 2
extra Release                SemaphoreFullException

2. Initial vs maximum count

new Semaphore(0, 10) starts with no slots: waiters block until someone releases. That turns a semaphore into a counting signal: each Release means "one more item is ready". This is how some producer/consumer queues are built; Channel<T> or BlockingCollection<T> are usually better.

3. WaitHandle integration

WaitHandle[] handles = [gpuSlots, shutdownEvent];
int which = WaitHandle.WaitAny(handles, TimeSpan.FromMinutes(1));
if (which == 0) { try { RunGpuJob(); } finally { gpuSlots.Release(); } }

Also usable with ThreadPool.RegisterWaitForSingleObject to run a callback when a slot becomes available without blocking a thread.

4. Platform notes

• Windows: named semaphores are kernel objects; Global\ / Local\ prefixes control session visibility, like mutexes.
• Linux / macOS: new Semaphore(..., name: "x") throws PlatformNotSupportedException (unnamed semaphores work). Named mutexes are emulated on Unix, named semaphores are not.
• Containers don't share kernel objects with each other by default anyway.

5. Leak safety

if (!slots.WaitOne(TimeSpan.FromSeconds(30)))
    throw new TimeoutException("No GPU slot available");
try
{
    RunJob();
}
finally
{
    slots.Release();   // exactly once, only after a successful wait
}

Rules: release only if the wait succeeded, release exactly once, always in finally. For named semaphores, plan crash recovery (watchdog, service restart, or a lease-based design).

6. Cost comparison (order of magnitude)

Measure on your hardware; the point is the order-of-magnitude difference.

7. Version notes

8. Try it yourself

1. Run the code example and confirm at most two jobs run at once; trigger SemaphoreFullException with an extra release.
2. Create new Semaphore(0, 5) and use it as a signal: a producer releases once per item and a consumer waits once per item.
3. On Linux, try to create a named semaphore and observe PlatformNotSupportedException.
4. On Windows, run two processes sharing a named semaphore of count 1; kill one while it holds the slot and observe the other blocking forever.
5. Benchmark Semaphore vs SemaphoreSlim wait/release pairs with BenchmarkDotNet.
6. Use WaitHandle.WaitAny with a semaphore and a shutdown ManualResetEvent.

using System.Threading;

using var gpuSlots = new Semaphore(initialCount: 2, maximumCount: 2);
// On Windows, a name makes it machine-wide: new Semaphore(2, 2, @"Global\Contoso.GpuJobs")

var workers = Enumerable.Range(1, 5).Select(id => new Thread(() =>
{
    gpuSlots.WaitOne();
    try
    {
        Console.WriteLine($"Job {id} started");
        Thread.Sleep(500);
    }
    finally
    {
        gpuSlots.Release();
    }
})).ToList();

workers.ForEach(t => t.Start());
workers.ForEach(t => t.Join());

try
{
    gpuSlots.Release(); // count is already at the maximum
}
catch (SemaphoreFullException)
{
    Console.WriteLine("Released too many times");
}