Semaphore
A semaphore S is an integer variable that, apart from
initialization, is accessed only through two standard atomic operations: wait()
and signal(). The wait() operation was originally termed P (from the Dutch
proberen, “to test”); signal() was originally called V (from verhogen, “to
increment”). The definition of wait() is as follows:
wait(S) { while (S <= 0)
; // busy wait
S--;
}
The definition of signal() is as follows:
signal(S) { S++;
}
All modifications to the integer value of the semaphore in
the wait() and signal() operations must be executed indivisibly. That is, when
one process modifies the semaphore value, no other process can simultaneously
modify that same semaphore value. In addition, in the case of wait(S), the
testing of the integer value of S (S ≤ 0), as well as its possible modification
(S--), must be executed without interruption.
Semaphore Usage
Operating systems often distinguish between counting and
binary semaphores. The value of a counting semaphore can range over an
unrestricted domain. The value of a binary semaphore can range only between 0
and 1. Thus, binary semaphores behave similarly to mutex locks. In fact, on
systems that do not provide mutex locks, binary semaphores can be used instead
for providing mutual exclusion.
Counting semaphores can be used to control access to a given
resource consisting of a finite number of instances. The semaphore is
initialized to the number of resources available. Each process that wishes to
use a resource performs a wait() operation on the semaphore (thereby
decrementing the count). When a process releases a resource, it performs a
signal() operation (incrementing the count). When the count for the semaphore
goes to 0, all resources are being used. After that, processes that wish to use
a resource willblock until the count becomes greater than 0.
