使用while的spin lock和直接用boolean + if完成lock 的例子
CriticalResourceUsingSynchronized.java
// 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();
}
}
}
}
<!-- /////////////////////// End Segment /////////////////////// -->
Lock.java
// 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;
}
}
<!-- /////////////////////// End Segment /////////////////////// -->
CriticalResourceUsingSynchronizedAndLocks.java
// 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();
}
}
<!-- /////////////////////// End Segment /////////////////////// -->
CriticalResourceUsingLocks.java
// 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();
}
}
<!-- /////////////////////// End Segment /////////////////////// -->