Reader Write Problem

semaphore readMutex=1

semaphore writeMutex=1

semaphore allowOneReader=1

int readcount=0

int writecount=0

semaphore readMain=1

semaphore writeMain=1

Reader protocol to read

allowOneReader.wait( );  

readMain.wait();  

 readMutex.wait();

     readcount++;

      if ( readcount == 1 )

         writeMain.wait();

 readMutex.signal();  

 readMain.signal();  

allowOnereader.signal();

<reader critical section>.

readMutex.wait();

readcount--;

if ( readcount == 0 )

      writeMain.signal();

readMutex.signal();

Writer protocol to write

writeMuex.wait();

   writecount++;

   if ( writecount == 1 )

          readMain.wait();

wrietMutex.signal();

writeMain.wait();

<writer critical section>;

wrietMain.signal();

wrietMutex.wait();

writecount--;

if ( writecount == 0 )

      readMain.signal();

writeMuex.signal();

Producer Consumer Problem (bounded) - Semaphores

Bounded by N buffers;
Solution:
semaphore full =0
semaphore empty = N
semaphore mutex = 1
producer() {
  while(true) {
    produce()
    empty.wait() //move one item from empty list taken to produce
    mutex.wait() //lock
    append()
    mutex.signal() //release lock
    full.signal() // fill the full with one more item ready for consume
  }
}
consumer() {
   while(true) {
    full.wait() // wait for fill to be filled by producer
     mutex.wait() //lock it and take away
     take()
    mutex.signal() //release lock
    empty.signal() // one more item got empty from the buffer
     consume()
  }
}

Producer Consumer Problem (unbounded) - Semaphores

Problem:

 producer () {

    while(true) {

        produce()

        append()

     }

}

Consumer() {

     while(true) {

         take()

         consume()

    }

}

In multithreading this may cause problem:

Solution:

semaphore mutex=1

semaphore full=0

producer() {

       while(true) {

          produce()

          mutex.wait()

          append()

          mutex.signal()

          full.signal() //increment full

      }

}

consumer () {

     while(true) {

         full.wait()  // while full is not filled by producer, decrement full

         mutex.wait()  // mutex to give signal

         take()

         mutex.signal()

         consume()

     }

}

 

 

semaphores

A semaphore is an integer with the following function

1.  Intialize

2. Wait : if negative then decrement and block

3. Signal : Increment and wake a blocked thread