AutoResetEvent和信号量与maximumCount = 1之间有什么区别吗？

Question

I'm going through the following article:

http://www.albahari.com/threading

and I cannot get to realize the difference between an AutoResetEvent and a Semaphore initialized with maximumCount = 1. Just to see if I'm getting things right... is there any difference in these two constructs, given that usage?

Thanks!

Answer 1

Yes, there certainly is a difference. A Semaphore is used to throttle access to a resource or block of code. When WaitOne is called a thread will block until a count from the semaphore becomes available. To make a count availabe you would call Release . A semaphore with a maximum count of 1 is often called a binary semaphore. A semaphore of this nature only allows access to a resource or block code from a single thread. You could use a binary semaphore in place of a mutex or monitor. The important thing to remember about the Semaphore is that its state is manually controlled via calls to WaitOne and Release .

An AutoResetEvent on the other hand is primarily used as a signaling mechanism. One thread will block via a call to WaitOne waiting for a signal. Another thread will call Set to initiate that signal. An ARE publishes this signal to one and only one thread and then immediately resets the ARE to an unsignaled state. The important thing to remember about the AutoResetEvent is that it is manually signaled via a call to Set and automatically reset after when a single call to WaitOne returns.

So here is a summary of differences:

• A Semaphore 's state is manually controlled.
• A AutoResetEvent 's state is manually set, but automatically reset.
• With a Semaphore threads typically balance the Release and WaitOne calls.
• With a AutoResetEvent one thread is typically designated as the signaler and another is the waiter.
• A Semaphore throttles access to a resource or block of code.
• A AutoResetEvent signals a thread to take some action.

Think of a AutoResetEvent as a door to a hallway. The door will allow one and only one person through the door after receiving a command to do so. Once a person goes through the door it immediately closes and waits for another command. As long as the door keeps receiving new commands the hallway is free to fill with as many people as the number of commands given.

Think of a Semaphore as a door to the same hallway. The door will allow a certain number of people in the hallway. The door remains open until the hallway reaches its occupancy limit at which time the door closes. After someone leaves the hallway through the other side then this door opens again.

Update:

Here is the simplest possible example that demonstrates that something is clearly different.

static void Main()
{
    var are = new AutoResetEvent(false);
    are.Set();
    are.Set();

    var semaphore = new Semaphore(0, 1);
    semaphore.Release();
    semaphore.Release();
}

It comes as no surprise that you will get an exception on the second semaphore.Release call whereas the second call to Set passes through just fine. The reason is because an ARE is setting a boolean flag whereas the semaphore is attempting to increase the count.

The WaitOne methods will work the same way, but the Release and Set methods will not. It is for this reason that a binary semaphore is not interchangable with an ARE. However, an ARE could be interchangable with a binary semaphore in some cases.

One scenario where there is overlap is in the case of a latch for a single thread.

public static void Main()
{
  var latch = new AutoResetEvent(false);

  new Thread(
    () =>
    {
      latch.WaitOne(); // Wait for the latch.
    }).Start();

  latch.Set(); // Release the latch.
}

Here is a scenario that can only be satisfied by a AutoResetEvent .

static void Main()
{
    var are = new AutoResetEvent(false);

    new Thread(
        () =>
        {
            while (true)
            {
                are.WaitOne();
                Console.WriteLine("go");
                Thread.Sleep(2000);
            }
        }).Start();

    while (true)
    {
        are.Set();
        Console.WriteLine("pulse");
        Thread.Sleep(1000);
    }

}

Answer 2

An AutoResetEvent , to use Joe Albahari's metaphor :

is like a ticket turnstile: inserting a ticket lets exactly one person through

so it's like a one-way door.

By contrast, a Semaphore with a count of one is like a room that can only hold one person and it has an "Occupied" sign. Semaphores are for controlling access to resources (the room) and the count specifies how many of the resources there are (how many people can fit in the room).

Answer 3

Mostly the same from the perspective of user, one minor difference is multiple consecutive signals on AutoResetEvent will succeed which makes it inappropriate to model the resource produce consumption problem. Check out below article - "An auto-reset event is just a stupid semaphore".

http://blogs.msdn.com/b/oldnewthing/archive/2006/06/22/642849.aspx

Answer 4

A semaphore with max 1 is just like a normal System.Threading.Monitor or a lock "if we ignore the fact that named system semaphores are visible throughout the operating system.." which provide a critical section "Only one thread is allow to access to this method or recourse and when finish using allow other thread to use it "if there is a waiting thread that is blocked until the current thread finish the using of the resource"." so only one thread can access a resource.

You can think of AutoResetEvent as a notifier , a thread will be wait until have notification from another thread to proceed and the other thread later will set to make another thread to wait for notification again "note that AutoResetEvent will automatically set the waiting thread again"...

An example to AutoRestEvent is producer/consumer using a collection, first thread will be waiting and element to be added to consume it, another thread "producer" whenever an element is added it signals "notify" a waiting thread "that were blocked waiting the notification", the first thread then will handle "consume" that new added element and then wait again until another element is added..

//Edit: If you already know the different between AutoResetEvent and the Semaphore and asking "as your comment"

If we restricted ourselves to using only WaitOne and Set for an ARE

If you just using _autoResetEvent.WaitOne() and _autoResetEvent.Set() then you can achieve the same result -but you should use it carefully- by using _semaphore.WaitOne() and _semaphore.Release() :

AutoResetEVent _autoResetEvent = new AutoResetEvent(true);
Semaphore _semaphore = new Semaphore(1, 1);

private void Foo()
{
    _autoResetEvent.WaitOne();
    try
    {
        //some code
        Console.WriteLine("Thread At Foo Entered {0}", Thread.CurrentThread.ManagedThreadId);
    }
    finaly
    {
        _autoResetEvent.Set();
    }
}

private void Bar()
{
    _semaphore.WaitOne();
    try
    {
        //some code
        Console.WriteLine("Thread At Bar Entered {0}", Thread.CurrentThread.ManagedThreadId);
    }
    finaly
    {
        _semaphore.Release();
    }
}

void Main()
{
    new Thread(Foo) { IsBackground = true }.Start();
    new Thread(Foo) { IsBackground = true }.Start();
    new Thread(Bar) { IsBackground = true }.Start();
    new Thread(Bar) { IsBackground = true }.Start();

    Thread.Sleep(2000);//give it some time to execute.
    Console.ReadLine();
}

//output is something like this:
Thread At Foo Entered 11
Thread At Foo Entered 12
Thread At Far Entered 13
Thread At Far Entered 14

Answer 5

A Semaphore is used to control the access to a critical section. Auto/ManualResetEvent is used when you want to signal other threads that a certain event has occurred so they can react on it - they have not really something to do with guarding the entry into a critical section.

I'm not sure which particular usage you refer to but I guess you could use locks and events to implement a semaphore so the answer to your question probably is no and yes depending on what you are after.