The semaphore class works similar to the
Monitor and Mutex class but lets you set a limit on how many threads have access
to a critical section. It's often described as a nightclub (the semaphore) where
the visitors (threads) stands in a queue outside the nightclub waiting for
someone to leave in order to gain entrance.
a piece of code that accesses a
shared resource (data structure or device)
but the condition is that only one thread can enter in this section in a time.
provide all the method and property which are require to implement Semaphore.
To use a semaphore in C#, you
first need to instantiate an instance of a Semaphore object. The constructor,
at a minimum, takes two parameters. The first is the number of resource slots
initially available when the object is instantiated. The second parameter is
the maximum number of slots available. If you want to reserve some slots for
the calling thread, you can do so by making the first parameter smaller than the
second. To reserve all slots for new threads, you should make both parameters
After you instantiated your Semaphore object,
you simply need to call the WaitOne() method when entering an area of code that
you want restricted to a certain number of threads. When processing finishes,
call the Release() method to release the slot back to the pool.
The count on a semaphore is decremented each
time a thread enters the semaphore, and incremented when a thread releases the
semaphore. When the count is zero, subsequent requests block until other threads
release the semaphore. When all threads have released the semaphore, the count
is at the maximum value specified when the semaphore was created.
Creating a new semaphore is accomplished
through one of the existing constructors:
Using the code
- Semaphore(Int32,Int32): Initializes a new instance of the Semaphore class,specifying the maximum number of concurrent entries and optionallyreserving some entries.
- Semaphore(Int32,Int32,String): Initializes a new instance of the Semaphore class, specifying themaximum number of concurrent entries, optionally reserving some entriesfor the calling thread, and optionally specifying the name of a systemsemaphore object.
- Semaphore(Int32,Int32,String,Boolean): Initializes a new instance of the Semaphore class, specifying themaximum number of concurrent entries, optionally reserving some entriesfor the calling thread, optionally specifying the name of a systemsemaphore object, and specifying a variable that receives a valueindicating whether a new system semaphore was created.
- Semaphore(Int32,Int32,String,Boolean,SemaphoreSecurity): Initializes a new instance of the Semaphore class, specifying themaximum number of concurrent entries, optionally reserving some entriesfor the calling thread, optionally specifying the name of a systemsemaphore object, specifying a variable that receives a value indicatingwhether a new system semaphore was created, and specifying security accesscontrol for the system semaphore.
Thread threads = new Thread;
Semaphore sem = new Semaphore(3, 3);
is waiting in line...", Thread.CurrentThread.Name);
enters the C_sharpcorner.com!", Thread.CurrentThread.Name);
is leaving the C_sharpcorner.com", Thread.CurrentThread.Name);
i = 0; i < 10; i++)
threads[i] = new Thread(C_sharpcorner);
threads[i].Name = "thread_" +
important facts about Semaphore
- There is no guaranteed order, such as FIFO or LIFO, in which blocked threads enter the semaphore.
- The Semaphore class does not enforce thread identity on calls to WaitOne() or Release(). It is the programmer's responsibility to ensure that threads do not release the semaphore too many times.
- For example, suppose a semaphore has a maximum count of two, and that thread A and thread B both enter the semaphore. If a programming error in thread B causes it to call Release twice, both calls succeed. The count on the semaphore is full, and when thread A eventually calls Release, a SemaphoreFullException is thrown.
- Semaphores are of two types: local semaphores and named system semaphores.
- If you create a Semaphore object using a constructor that accepts a name, it is associated with an operating-system semaphore of that name.
- Named system semaphores are visible throughout the operating system, and can be used to synchronize the activities of processes.
- You can create multipleSemaphore objects that represent the same named system semaphore, and you can use the OpenExisting() method to open an existing named system semaphore.
- A local semaphore exists only within your process. It can be used by any thread in your process that has a reference to the local Semaphore object.
- Each Semaphore object is a separate local semaphore.