CareerCup

The basic structure of the reader writer problem is like

--Reader()
Wait until no writers
Access database
Check out - wake up a waiting writer

--Writer()
Wait until no active reader or writer
Access the database
Check out - wake waiting reader or writer

The detailed translation would be something like this

Reader()
{
//first check self into the system
lock.acquire();
while((AW+WW) > 0) // is it safe to read ?
{
     WR++; // No. Writers exist.
     OkToRead.wait(&lock); // sleep on condition variable
     WR--;  // No longer waiting
}
     AR++;
     lock.release();
     // perform actual read-only access
     AccessDataBase(readonly);
     //Now, check out of the system
     lock.acquire();
     AR--; // no longer active
     if(AR == 0 && WW > 0) // no other active readers
          OkToWrite.signal(); // wake up one writer
     lock.release();
}

//Logic for writer
Writer()
{
   // first check self into the system
   while((AW+AR)>0){ // Is it safe to write ?
         WW++; // No. active users exist
         OkToWrite.wait(&lock); //sleep on cond variable
         WW--; // no longer waiting
   }
   AW++; // Now we are active
   lock.release();
   // perform actual write access
   AccessDataBase(Write);
   
   // Now check out of the system
   lock.acquire();
   AW--;  // no longer active
   if(WW > 0){   // give priority to writers
         OkToWrite.signal(); // wake up one writer
   }else if(WR > 0){  // otherwise wake readers
     OkToRead.broadcast(); // wake all readers.
   }
   lock.release();
}

This problem is tough to get right and lot depends on the which all process are atomic. I think in the above solution also readers may starve
at this Reader() entry code
while((AW+WW) > 0) // is it safe to read ?

oops i forgot to metion what the variables mean.
Here it goes
AR -> activer reader
WR -> waiting reader
WW -> waiting writer
AW -> Active writer