Semaphore is a hardware-based solution to the critical section problem. Dijkstra proposed the concept of semaphore in 1965. Semaphore provides general purpose solution to impose mutual exclusion among concurrently executing processes, where many processes want to execute in their critical section but only one at a time is allowed and rest all other are excluded.
A semaphore basically consists of an integer variable S, shared by processes.
S is a protected variable that can only be accessed and manipulate by two operation:- wait() and signal().
Wait() and signal() are semaphore primitives
The wait is sometimes called down(), P(), or Sleep() and signal is called up(), v() or Wake up().
The wait and signal primitives ensures that one process at a time enters in its critical section and rest all other processes wanting to in their critical sections are kept waiting.
Semaphore is an integer variable that are used to accessed the shared resources through two standard atomatic operations: wait() and signal(). Here, wait means to test and signal means to increment.

The classical definition of wait() is :
wait()
{
while (S<=0);
//busy wait
S=S-1;
}

The classical definition of signal() is:
signal()
{
S=S+1;
}

Properties of semaphore:
1. It is simple and always have a non-negative integer value
2. Works with many processes
3. Can have many different critical sections with different semaphores
4. Each critical section has unique access semaphores.
5. Can permit multiple processes into critical section at once, if desirable.
6. Solution to critical section
7. Act as resource management
8. It also decide the order of execution among the process( n-process)

Semaphores are of two types:

1.Binary Semaphore –
Binary semaphore is also known as a mutex lock. It can have only two values – 0 and 1. Its value is initialized to 1. It is used to implement the solution of critical section problems with multiple processes. Implementation of Binary semaphore:

Down ( semaphore S)
{
if(S.value==1)
{
S.value=0;
}
else
{
//perform block operation and move the process to thesemaphore queue* or put process(PCB) in suspended list
Sleep() or block ();
}
}

Up(semaphore S)
{
if (semaphore queue is empty)
{
S.value=1;
}
else
{
/* semaphore queue is not empty, perform wakeup( ) and move the firstprocess from semaphores queue to the ready queue or remove a process (P) from suspended list*/
wakeup(P);
}
}

2.Counting Semaphore –
The value of counting semaphore can range over an unrestricted domain(-∞ to ∞).
Counting semaphores can be used to control access to a given resource consisting of finite number of instances.
The semaphore is initialized to the number of resources available.
Each processes 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 a count for the semaphore goes to all ’0’,all resources are being used.
After that, processes that wish to use a resource will block until the count becomes greater than ‘ 0’.