1. wait( S )
{
while( S <= 0) ;
S--;
}

2. signal( S )
{
S++;
}

static int readcount = 0;
wait (mutex);
readcount ++; // on each entry of reader increment readcount
if (readcount == 1)
{
  wait (write);
}
signal(mutex);

--READ THE FILE?

wait(mutex);
readcount --; // on every exit of reader decrement readcount
if (readcount == 0)
{
  signal (write);
}
signal(mutex);

wait(write);
WRITE INTO THE FILE
signal(wrt);

Explanation :
The initial value of semaphore write = 1
Suppose two processes P0 and P1 wants to write, let P0 enter first the writer code, The moment P0 enters
 Wait( write ); will decrease semaphore write by one, now write = 0
And continue WRITE INTO THE FILE
Now suppose P1 wants to write at the same time (will it be allowed?) let's see.
P1 does Wait( write ), since the write value is already 0, therefore from the definition of wait, it will go into an infinite loop (i.e. Trap), hence P1 can never write anything, till P0 is writing.
Now suppose P0 has finished the task, it will
signal( write); will increase semaphore write by 1, now write = 1
if now P1 wants to write it since semaphore write > 0
This proofs that, if one process is writing, no other process is allowed to write.

Explanation:
Initial value of semaphore mutex = 1 and variable readcount = 0
Suppose two processes P0 and P1 are in a system, P0 wants to read while P1 wants to write, P0 enter first into the reader code, the moment P0 enters 
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 1, next
if (readcount == 1)// evaluates to TRUE
{
  wait (write); // decrement write by 1, i.e. write = 0(which   
                   clearly proves that if one or more than one 
                   reader is reading then no writer will be  
                   allowed.
}

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to enter.

And reader continues to --READ THE FILE?

Suppose now any writer wants to enter into its code then:

As the first reader has executed wait (write); because of which write value is 0, therefore wait(writer); of the writer, code will go into an infinite loop and no writer will be allowed.
This proofs that, if one process is reading, no other process is allowed to write.
Now suppose P0 wants to stop the reading and wanted to exit then
Following sequence of instructions will take place:
wait(mutex); // decrease mutex by 1, i.e. mutex = 0
readcount --; // readcount = 0, i.e. no one is currently reading
if (readcount == 0) // evaluates TRUE
{
  signal (write); // increase write by one, i.e. write = 1 
}
signal(mutex);// increase mutex by one, i.e. mutex = 1

Now if again any writer wants to write, it can do it now, since write > 0

Explanation:
The initial value of semaphore write = 1
Suppose two processes P0 and P1 are in a system, P0 wants to write while P1 wants to read, P0 enter first into the writer code, The moment P0 enters 
Wait( write ); will decrease semaphore write by 1, now write = 0
And continue WRITE INTO THE FILE
Now suppose P1 wants to read the same time (will it be allowed?) let's see.
P1 enters reader's code
Initial value of semaphore mutex = 1 and variable readcount = 0
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 1, next
if (readcount == 1)// evaluates to TRUE
{
  wait (write); // since value of write is already 0, hence it 
                   will enter into an infinite loop and will not be  
                   allowed to proceed further (which clearly 
                   proves that if one writer is writing then no  
                   reader will be allowed.
}

The moment writer stops writing and willing to exit then 
This proofs that, if one process is writing, no other process is allowed to read.

The moment writer stops writing and willing to exit then it will execute:
signal( write); will increase semaphore write by 1, now write = 1
if now P1 wants to read it can since semaphore write > 0 

Explanation :
Initial value of semaphore mutex = 1 and variable readcount = 0
Suppose three processes P0, P1 and P2 are in a system, all the three processes P0, P1, and P2 want to read, let P0 enter first into the reader code, the moment P0 enters 
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 1, next
if (readcount == 1)// evaluates to TRUE
{
  wait (write); // decrement write by 1, i.e. write = 0(which   
                   clearly proves that if one or more than one 
                   reader is reading then no writer will be  
                   allowed.
}

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to enter.

And P0 continues to --READ THE FILE?

→Now P1 wants to enter the reader code
current value of semaphore mutex = 1 and variable readcount = 1
let P1 enter into the reader code, the moment P1 enters 
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 2, next
if (readcount == 1)// eval. to False, it will not enter if block

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to enter.

Now P0 and P1 continues to --READ THE FILE?

→Now P2 wants to enter the reader code
current value of semaphore mutex = 1 and variable readcount = 2
let P2 enter into the reader code, The moment P2 enters 
Wait( mutex ); will decrease semaphore mutex by 1, now mutex = 0
Increment readcount by 1, now readcount = 3, next
if (readcount == 1)// eval. to False, it will not enter if block

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to enter.

Now P0, P1, and P2 continues to --READ THE FILE?


Suppose now any writer wants to enter into its code then:

As the first reader P0 has executed wait (write); because of which write value is 0, therefore wait(writer); of the writer, code will go into an infinite loop and no writer will be allowed.  

Now suppose P0 wants to come out of system( stop reading) then
wait(mutex); //will decrease semaphore mutex by 1, now mutex = 0
readcount --; // on every exit of reader decrement readcount by 
                 one i.e. readcount = 2

if (readcount == 0)// eval. to FALSE it will not enter if block

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to exit


→ Now suppose P1 wants to come out of system (stop reading) then
wait(mutex); //will decrease semaphore mutex by 1, now mutex = 0
readcount --; // on every exit of reader decrement readcount by 
                 one i.e. readcount = 1

if (readcount == 0)// eval. to FALSE it will not enter if block

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 i.e. other readers are allowed to exit

→Now suppose P2 (last process) wants to come out of system (stop reading) then
wait(mutex); //will decrease semaphore mutex by 1, now mutex = 0
readcount --; // on every exit of reader decrement readcount by 
                 one i.e. readcount = 0

if (readcount == 0)// eval. to TRUE it will enter into if block
{
  signal (write); // will increment semaphore write by one, i.e. 
                     now write = 1, since P2 was the last process
                     which was reading, since now it is going out, 
                     so by making write = 1 it is allowing the writer    
                     to write now.
}

signal(mutex); // will increase semaphore mutex by 1, now mutex = 1 


The above explanation proves that if one or more than one processes are willing to read simultaneously then they are allowed.