// This solves the readers/writers problem only using synchronized

public class CriticalResourceUsingSynchronized
{
     private     Integer     m_readLock = new Integer(0);
     private     int     m_reading =     0;

     public int read()
     {
          int readData = 0;
          
          // lock readers
          synchronized( m_readLock )
          {
               // if we are the first reader lock writers

               // this is what we wanted to do from the pseudo code:
               //     if( m_reading == 0 )
               //           lock writers
               //
               //  But there is no way to do this with synchronized so
               //  the writer has to do a spin lock on m_reading

               // increment semaphore
               m_reading++;

          }     // unlock readers

          // do read  (may take significant time...)

          // lock readers
          synchronized( m_readLock )
          {
               // decrement semaphore
               m_reading--;

               // from the pseudo code we wanted to do this:
               //     if( m_reading == 0 )
               //           unlock writers
               //
               // but synchonized doesn't cut it here so the writer is
               // polling m_reading (i.e. spin lock) to see when it goes to 0

          }// unlock readers
          
          // return the read data
          return readData;
     }

     public void write( int x )
     {
          // we want to
          //
          // lock writers
          // write
          // unlock writers
          //
          // but since we are only using synchronized we have to spin lock;
          // because synchronized is not a lock; it is this weird linked
          // critical section thing.

          // spin lock waiting for m_readers to go to 0
          boolean succeeded = false;
          while( !succeeded )
          {
               synchronized( m_readLock )
               {
                    if( m_reading == 0 )
                    {
                         // we did it! m_readers is 0, and no readers can get in
                         // because we have locked m_readLock

                         // do write (may take significant time...)

                         // we can break out of this crazy spin lock!
                         succeeded = true;
                    }
               }

                if( succeeded == false )
               {
                    // we failed; there are still readers so let them compute
                    // so yeild the rest of our time slice so we don't check
                    // again before any other thread has a chance to do anything
                    Thread.currentThread().yield();
               }
          }
     }
}

		

// Lock.java
//
// This class implements a boolean lock object in java
//

class Lock extends Object
{
     private boolean m_bLocked = false;

     public synchronized void lock()
     {
          // if some other thread locked this object then we need to wait
          // until they release the lock
          if( m_bLocked )
          {
               do
               {
                    try
                    {
                         // this releases the synchronized that we are in
                         // then waits for a notify to be called in this object
                         // then does a synchronized again before continuing
                         wait();
                    }
                    catch( InterruptedException e )
                    {
                         e.printStackTrace();
                    }
                    catch( Exception e )
                    {
                         e.printStackTrace();
                    }
               } while( m_bLocked );     // we can't leave until we got the lock, which
                                             // we may not have got if an exception occured
          }

          m_bLocked = true;
     }

     public synchronized boolean lock( long milliSeconds )
     {
          if( m_bLocked )
          {
               try
               {
                    wait( milliSeconds );
               }
               catch( InterruptedException e )
               {
                    e.printStackTrace();
               }

               if( m_bLocked )
               {
                    return false;
               }
          }

          m_bLocked = true;
          return true;
     }

     public synchronized boolean lock( long milliSeconds, int nanoSeconds )
     {
          if( m_bLocked )
          {
               try
               {
                    wait( milliSeconds, nanoSeconds );
               }
               catch( InterruptedException e )
               {
                    e.printStackTrace();
               }

               if( m_bLocked )
               {
                    return false;
               }
          }

          m_bLocked = true;
          return true;
     }

     public synchronized void releaseLock()
     {
          if( m_bLocked )
          {
               m_bLocked = false;
               notify();
          }
     }

     public synchronized boolean isLocked()
     {
          return m_bLocked;
     }
}

		

// This solves the readers/writers problem only using synchronized and the Lock class
import Lock;

public class CriticalResourceUsingSynchronizedAndLocks
{
     private     Integer     m_readLock = new Integer(0);
     private     int     m_reading =     0;
     private Lock m_writeLock = new Lock();

     public int read()
     {
          int readData = 0;
          
          // lock readers
          synchronized( m_readLock )
          {
               // if we are the first reader lock writers

               if( m_reading == 0 )
                    // lock the writers
                    m_writeLock.lock();

               // increment semephore
               m_reading++;

          }     // unlock readers

          // do read  (may take significant time...)

          // lock readers
          synchronized( m_readLock )
          {
               // decrement semaphore
               m_reading--;

               if( m_reading == 0 )
                    // release the writers
                    m_writeLock.releaseLock();

          }// unlock readers
          
          // return read value
          return readData; 
     }

     public void write( int x )
     {
          // lock writers
          m_writeLock.lock();

          // do writing

          // release writers
          m_writeLock.releaseLock();
     }
}

		

// This solves the readers/writers problem only the Lock class
import Lock;

public class CriticalResourceUsingLocks
{
     private     Lock m_readLock = new Lock();
     private     int     m_reading =     0;
     private Lock m_writeLock = new Lock();

     public int read()
     {
          int readData = 0;

          // lock readers
          m_readLock.lock();

          // if we are the first reader lock writers
          if( m_reading == 0 )
               // lock the writers
               m_writeLock.lock();

          // increment semephore
          m_reading++;

          // unlock readers
          m_readLock.releaseLock();

          // do read  (may take significant time...)

          // lock readers
          m_readLock.lock();

          // decrement semaphore
          m_reading--;

          if( m_reading == 0 )
               // release the writers
               m_writeLock.releaseLock();

          // unlock readers
          m_readLock.releaseLock();
          
          // return read data
          return readData;
     }

     public void write( int x )
     {
          // lock writers
          m_writeLock.lock();

          // do writing

          // release writers
          m_writeLock.releaseLock();
     }
}