Concept of semaphores in operating system


Semaphore is a mechanism to decide resources struggles by matching resource searchers what is the province of sought resources, accomplishing a common sole entree to resources. Often semaphore operates as a type of common sole counters ( such as mutexes ) where it holds a figure of entree keys to the resources. Procedure that seeks the resources must obtain one of those entree keys, one of semaphores before it proceeds further to use the resource. If there is no more such a cardinal available to the procedure, it has to wait for the current resource user to let go of the key.


There are two sorts of semaphores:

We will write a custom essay sample on
Concept of semaphores in operating system
or any similar topic only for you
Order now
  1. Readers/writer locks
  2. Counting semaphores, though the readers/writer lock manner of semaphore is preferred.

A readers/writer lock semaphore contains no expressed mention tie ining it with the shared informations it protects. You maintain the association merely by programming collaborating togss to get the semaphore before accessing the information. This manner of programming allows multiple togss ( readers ) to read the informations associated with the semaphore at the same time, but allows merely one yarn at a clip ( a author ) to modify the information.


There are two sorts of readers/writer lock semaphores:

1 ) local semaphores: it can merely be used within undertakings

2 ) recoverable semaphores: it can be shared among undertakings. A recoverable semaphore has the ability to retrieve when the yarn keeping the semaphore out of the blue terminates without let go ofing the semaphore ; in this instance, the recoverable semaphore restores itself to an unbarred province and unblocks any togss waiting to get it. This capableness is indispensable for forestalling dead ends affecting semaphores that are shared among undertakings.


Semaphores can merely be accessed by two operations ( they will be system calls )



semaphore S shared integer variable normally initialized to 1

P ( S ) : trap to the meat

disable interrupts ( so semaphore entree is atomic )

if S & A ; gt ; 0 so S: = S – 1

else { line up the procedure on S, alteration its province to barricade,

agenda another procedure }

enable interrupts


V ( S ) : trap to the meat

disable interrupts

if S = 0 and line up on S is non empty so

{ pick a procedure from the waiting line on S,

alteration its province from blocked to cook }

else S: = S + 1

enable interrupts


if we have a shared-memory multiprocessor alternatively of a single-processor, so disenabling interrupts to entree S atomically is non good plenty since disenabling interrupts on one processor has no consequence on another processor alternatively we use test_and_set on a lock variable internal to the meat, where there is a lock variable for each semaphore a test_and_set which busy delaies internal to the OS is non considered a busy-waiting solution to the common exclusion job because the procedure making the P operation is blocked if S is 0 or we can lock the coach and unlock it when done Now we can implement

mutex_begin: P ( S )

mutex_end: V ( S )

Semaphores can be used in two ways

1. common exclusion to avoid race conditions in accessing shared informations in critical subdivisions in at the same time put to deathing procedures

P ( S ) count++ V ( S ) /* S merely takes on values 0, 1 */

S is called a double star semaphore

2. procedure synchronism ( besides called status synchronism )

3. P ( empty ) … V ( full )

4. P ( full ) … V ( empty )

Therefore semaphore represents the figure of resources available and is called as numeration semaphores


Hi there, would you like to get such a paper? How about receiving a customized one? Check it out