public void AwaitUninterruptibly()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
UninterruptableThread thread = new UninterruptableThread(myLock.WriterLock, c);
thread.InternalThread.Start();
while (!thread.lockStarted)
{
Thread.Sleep(new TimeSpan(0, 0, 0, 0, 100));
}
myLock.WriterLock.Lock();
try
{
thread.InternalThread.Interrupt();
thread.canAwake = true;
c.Signal();
}
finally
{
myLock.WriterLock.Unlock();
}
thread.InternalThread.Join();
Assert.IsTrue(thread.interrupted);
Assert.IsFalse(thread.InternalThread.IsAlive);
}
public void Lock()
{
ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
rl.WriterLock.Lock();
Assert.IsTrue(rl.IsWriteLockHeld);
Assert.IsTrue(rl.WriterLockedByCurrentThread);
// assertTrue(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
Assert.AreEqual(0, rl.ReadLockCount);
rl.WriterLock.Unlock();
Assert.IsFalse(rl.IsWriteLockHeld);
Assert.IsFalse(rl.WriterLockedByCurrentThread);
// assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
Assert.AreEqual(0, rl.ReadLockCount);
rl.ReaderLock.Lock();
Assert.IsFalse(rl.IsWriteLockHeld);
Assert.IsFalse(rl.WriterLockedByCurrentThread);
// assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
Assert.AreEqual(1, rl.ReadLockCount);
rl.ReaderLock.Unlock();
Assert.IsFalse(rl.IsWriteLockHeld);
Assert.IsFalse(rl.WriterLockedByCurrentThread);
// assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
Assert.AreEqual(0, rl.ReadLockCount);
}
public void AwaitUninterruptibly()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
UninterruptableThread thread = new UninterruptableThread(myLock.WriterLock, c);
thread.InternalThread.Start();
while (!thread.lockStarted)
{
Thread.Sleep(new TimeSpan(0, 0, 0, 0, 100));
}
myLock.WriterLock.Lock();
try
{
thread.InternalThread.Interrupt();
thread.canAwake = true;
c.Signal();
}
finally
{
myLock.WriterLock.Unlock();
}
thread.InternalThread.Join();
Assert.IsTrue(thread.interrupted);
Assert.IsFalse(thread.InternalThread.IsAlive);
}
public void GetQueueLength()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
Thread t1 = new Thread(new InterruptedLockRunnable(myLock).Run);
Thread t2 = new Thread(new InterruptibleLockRunnable(myLock).Run);
Assert.AreEqual(0, myLock.QueueLength);
myLock.WriterLock.Lock();
t1.Start();
Thread.Sleep(new TimeSpan(10000 * Delays.Short.Milliseconds));
Assert.AreEqual(1, myLock.QueueLength);
t2.Start();
Thread.Sleep(new TimeSpan(10000 * Delays.Short.Milliseconds));
Assert.AreEqual(2, myLock.QueueLength);
t1.Interrupt();
Thread.Sleep(new TimeSpan(10000 * Delays.Short.Milliseconds));
Assert.AreEqual(1, myLock.QueueLength);
myLock.WriterLock.Unlock();
Thread.Sleep(new TimeSpan(10000 * Delays.Short.Milliseconds));
Assert.AreEqual(0, myLock.QueueLength);
t1.Join();
t2.Join();
}
/// <summary> Acquires the read lock unless <see cref="System.Threading.Thread.Interrupt()"/> is called on the current thread</summary>
/// <remarks>
/// <p/>
/// Acquires the read lock if the write lock is not held
/// by another thread and returns immediately.
///
/// <p/>
/// If the write lock is held by another thread then the
/// current thread becomes disabled for thread scheduling
/// purposes and lies dormant until one of two things happens:
///
/// <ul>
/// <li>The read lock is acquired by the current thread</li>
/// <li>Some other thread calls <see cref="System.Threading.Thread.Interrupt()"/> on the current thread.</li>
/// </ul>
///
/// <p/>If <see cref="System.Threading.Thread.Interrupt()"/> is called on the current thread,
/// a <see cref="System.Threading.ThreadInterruptedException"/> is thrown
///
/// <p/>
/// In this implementation, as this method is an explicit
/// interruption point, preference is given to responding to
/// the interrupt over normal or reentrant acquisition of the
/// lock.
/// </remarks>
/// <exception cref="System.Threading.ThreadInterruptedException">if the current thread is interrupted.</exception>
public override IDisposable LockInterruptibly()
{
ThreadInterruptedException ie = null;
lock (this)
{
if (!ReentrantReadWriteLock.StartReadFromNewReader())
{
for (;;)
{
try
{
Monitor.Wait(this);
if (ReentrantReadWriteLock.StartReadFromWaitingReader())
{
return(this);
}
}
catch (ThreadInterruptedException ex)
{
ReentrantReadWriteLock.CancelWaitingReader();
ie = ex;
break;
}
}
}
}
if (ie != null)
{
ReentrantReadWriteLock.SignallerWriterLock.SignalWaiters();
throw ie;
}
return(this);
}
public void Constructor()
{
ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
Assert.IsFalse(rl.IsFair);
Assert.IsFalse(rl.IsWriteLockHeld);
Assert.AreEqual(0, rl.ReadLockCount);
}
public void Await_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
myLock.WriterLock.Lock();
myLock.WriterLock.Unlock();
}
/// <summary>
/// Acquires the write lock if it is not held by another thread
/// within the given waiting time and <see cref="System.Threading.Thread.Interrupt()"/> has not been called on the current thread
/// </summary>
/// <remarks>
/// Acquires the write lock if neither the read nor write lock
/// are held by another thread
/// and returns immediately with the value <see lang="true"/>,
/// setting the write lock hold count to one. If this lock has been
/// set to use a fair ordering policy then an available lock
/// <b>will not</b> be acquired if any other threads are
/// waiting for the write lock. This is in contrast to the <see cref="Spring.Threading.Locks.WriterLock.TryLock()"/>
/// If you want a timed <see cref="Spring.Threading.Locks.WriterLock.TryLock()"/>
/// that does permit barging on a fair lock, then combine the
/// timed and un-timed forms together:
///
/// <code>
/// if (lock.TryLock() || lock.tryLock(timeSpan) ) { ... }
/// </code>
///
/// <p/>
/// If the current thread already holds this lock then the
/// hold count is incremented by one and the method returns
/// <see lang="true"/>.
///
/// <p/>
/// If the lock is held by another thread then the current
/// thread becomes disabled for thread scheduling purposes and
/// lies dormant until one of three things happens:
///
/// <ul>
/// <li>The write lock is acquired by the current thread</li>
/// <li>Some other thread calls <see cref="System.Threading.Thread.Interrupt()"/>
/// on the current thread</li>
/// <li>The specified <see cref="System.TimeSpan"/> elapses</li>
/// </ul>
///
/// <p/>
/// If the write lock is acquired then the value <see lang="true"/> is
/// returned and the write lock hold count is set to one.
///
/// <p/>
/// If the current thread has <see cref="System.Threading.Thread.Interrupt()"/> called on it while acquiring
/// the write lock, then a <see cref="System.Threading.ThreadInterruptedException"/> is thrown.
///
/// <p/>
/// If the specified <see cref="System.TimeSpan"/> elapses then the value
/// <see lang="false"/> is returned. If the time is less than or
/// equal to zero, the method will not wait at all.
///
/// <p/>
/// In this implementation, as this method is an explicit
/// interruption point, preference is given to responding to
/// the interrupt over normal or reentrant acquisition of the
/// lock, and over reporting the elapse of the waiting time.
///
/// </remarks>
/// <param name="durationToWait">the time to wait for the write lock</param>
/// <returns> <see lang="true"/> if the lock was free and was acquired
/// by the current thread, or the write lock was already held by the
/// current thread; and <see lang="false"/> if the waiting time
/// elapsed before the lock could be acquired.
/// </returns>
///
/// <exception cref="System.Threading.ThreadInterruptedException">if the current thread is interrupted.</exception>
public override bool TryLock(TimeSpan durationToWait)
{
ThreadInterruptedException ie = null;
lock (this)
{
if (durationToWait.TotalMilliseconds <= 0)
{
return(ReentrantReadWriteLock.StartWrite());
}
else if (ReentrantReadWriteLock.StartWriteFromNewWriter())
{
return(true);
}
else
{
DateTime deadline = DateTime.Now.Add(durationToWait);
for (;;)
{
try
{
Monitor.Wait(this, durationToWait);
}
catch (ThreadInterruptedException ex)
{
ReentrantReadWriteLock.CancelWaitingWriter();
Monitor.Pulse(this);
ie = ex;
break;
}
if (ReentrantReadWriteLock.StartWriteFromWaitingWriter())
{
return(true);
}
else
{
if (deadline.Subtract(DateTime.Now).TotalMilliseconds <= 0)
{
ReentrantReadWriteLock.CancelWaitingWriter();
Monitor.Pulse(this);
break;
}
}
}
}
}
ReentrantReadWriteLock.SignallerReaderLock.SignalWaiters();
if (ie != null)
{
throw ie;
}
else
{
return(false);
}
}
public void ReadHoldingWriterLock()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.WriterLock.Lock();
Assert.IsTrue(myLock.ReaderLock.TryLock());
myLock.ReaderLock.Unlock();
myLock.WriterLock.Unlock();
}
public void AwaitNanos_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
myLock.WriterLock.Lock();
Assert.IsFalse(c.Await(new TimeSpan(1)));
myLock.WriterLock.Unlock();
}
public void AwaitNanos_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
myLock.WriterLock.Lock();
Assert.IsFalse(c.Await(new TimeSpan(1)));
myLock.WriterLock.Unlock();
}
public void WriteTryLockWhenReadLocked()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.ReaderLock.Lock();
Thread t = new Thread(new AnonymousClassRunnable14(myLock).Run);
t.Start();
t.Join();
myLock.ReaderLock.Unlock();
}
public void WriteTryLock_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.WriterLock.Lock();
Thread t = new Thread(new AnonymousClassRunnable15(myLock).Run);
t.Start();
t.Join();
myLock.WriterLock.Unlock();
}
public void ReadTryLock_Interrupted()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.WriterLock.Lock();
Thread t = new Thread(new AnonymousClassRunnable3(myLock).Run);
t.Start();
t.Interrupt();
t.Join();
}
public void MultipleReadLocks()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.ReaderLock.Lock();
Thread t = new Thread(new AnonymousClassRunnable6(myLock).Run);
t.Start();
t.Join();
myLock.ReaderLock.Unlock();
}
public void AwaitUntil_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
myLock.WriterLock.Lock();
DateTime d = DateTime.Now;
myLock.WriterLock.Unlock();
}
public void Unlock_IllegalMonitorStateException()
{
ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
try
{
rl.WriterLock.Unlock();
Assert.Fail("Should throw an exception.");
}
catch (SynchronizationLockException)
{
}
}
public void WriteLockInterruptibly_Interrupted()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
Thread t = new Thread(new AnonymousClassRunnable(myLock).Run);
myLock.WriterLock.Lock();
t.Start();
Thread.Sleep(Delays.Short);
t.Interrupt();
Thread.Sleep(Delays.Short);
myLock.WriterLock.Unlock();
t.Join();
}
public void WriteLockToString()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
String us = myLock.WriterLock.ToString();
Assert.IsTrue(us.IndexOf("Unlocked") >= 0);
myLock.WriterLock.Lock();
String ls = myLock.WriterLock.ToString();
Assert.IsTrue(ls.IndexOf("Locked") >= 0);
}
public void ReadLockToString()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
String us = myLock.ReaderLock.ToString();
Assert.IsTrue(us.IndexOf("Read locks = 0") >= 0);
myLock.ReaderLock.Lock();
myLock.ReaderLock.Lock();
String rs = myLock.ReaderLock.ToString();
Assert.IsTrue(rs.IndexOf("Read locks = 2") >= 0);
}
public void AwaitUntil_Interrupt()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
Thread t = new Thread(new AnonymousClassRunnable22(myLock, c).Run);
t.Start();
Thread.Sleep(new TimeSpan(Delays.Short.Milliseconds));
t.Interrupt();
t.Join(Delays.Short);
Assert.IsFalse(t.IsAlive);
}
public void AwaitNanos_Interrupt()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
Thread t = new Thread(new AnonymousClassRunnable21(myLock, c).Run);
t.Start();
Thread.Sleep(new TimeSpan((Int64) 10000*Delays.Short.Milliseconds));
t.Interrupt();
t.Join(Delays.Short);
Assert.IsFalse(t.IsAlive);
}
public void GetWriteHoldCount()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
for (int i = 1; i <= DEFAULT_COLLECTION_SIZE; i++)
{
myLock.WriterLock.Lock();
Assert.AreEqual(i, myLock.WriteHoldCount);
}
for (int i = DEFAULT_COLLECTION_SIZE; i > 0; i--)
{
myLock.WriterLock.Unlock();
Assert.AreEqual(i - 1, myLock.WriteHoldCount);
}
}
public void Await()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
Thread t = new Thread(new AnonymousClassRunnable19(myLock, c).Run);
t.Start();
Thread.Sleep(new TimeSpan(10000 * Delays.Short.Milliseconds));
myLock.WriterLock.Lock();
c.Signal();
myLock.WriterLock.Unlock();
t.Join(Delays.Short);
Assert.IsFalse(t.IsAlive);
}
public void Await_IllegalMonitor()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
try
{
c.Await();
Assert.Fail("Should throw an exception.");
}
catch (SynchronizationLockException)
{
}
}
/// <summary> Attempts to release this lock.</summary>
/// <remarks>
/// <p/> If the number of readers is now zero then the lock
/// is made available for write lock attempts.
/// </remarks>
public override void Unlock()
{
switch (ReentrantReadWriteLock.EndRead())
{
case ReentrantReadWriteLock.Signaller.READER:
ReentrantReadWriteLock.SignallerReaderLock.SignalWaiters();
break;
case ReentrantReadWriteLock.Signaller.WRITER:
ReentrantReadWriteLock.SignallerWriterLock.SignalWaiters();
break;
default:
break;
}
}
public void Await()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
Thread t = new Thread(new AnonymousClassRunnable19(myLock, c).Run);
t.Start();
Thread.Sleep(new TimeSpan(10000*Delays.Short.Milliseconds));
myLock.WriterLock.Lock();
c.Signal();
myLock.WriterLock.Unlock();
t.Join(Delays.Short);
Assert.IsFalse(t.IsAlive);
}
public void ReadAfterWriterLock()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.WriterLock.Lock();
Thread t1 = new Thread(new AnonymousClassRunnable9(myLock).Run);
Thread t2 = new Thread(new AnonymousClassRunnable10(myLock).Run);
t1.Start();
t2.Start();
Thread.Sleep(new TimeSpan(Delays.Short.Milliseconds * 10000));
myLock.WriterLock.Unlock();
t1.Join(Delays.Medium);
t2.Join(Delays.Medium);
Assert.IsTrue(!t1.IsAlive);
Assert.IsTrue(!t2.IsAlive);
}
public void ToStringTest()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
String us = myLock.ToString();
Assert.IsTrue(us.IndexOf("Write locks = 0") >= 0);
Assert.IsTrue(us.IndexOf("Read locks = 0") >= 0);
myLock.WriterLock.Lock();
String ws = myLock.ToString();
Assert.IsTrue(ws.IndexOf("Write locks = 1") >= 0);
Assert.IsTrue(ws.IndexOf("Read locks = 0") >= 0);
myLock.WriterLock.Unlock();
myLock.ReaderLock.Lock();
myLock.ReaderLock.Lock();
String rs = myLock.ToString();
Assert.IsTrue(rs.IndexOf("Write locks = 0") >= 0);
Assert.IsTrue(rs.IndexOf("Read locks = 2") >= 0);
}
/// <summary>
/// Attempts to release this lock.
/// </summary>
/// <remarks>
/// If the current thread is the holder of this lock then
/// the hold count is decremented. If the hold count is now
/// zero, the lock is released. If the current thread is
/// not the holder of this lock then <see cref="System.Threading.SynchronizationLockException"/>
/// is thrown.
/// </remarks>
/// <exception cref="System.Threading.SynchronizationLockException">if the current thread is not the holder of this lock.</exception>
public override void Unlock()
{
if (!IsHeldByCurrentThread)
{
throw new SynchronizationLockException("Current thread does not hold this lock.");
}
switch (ReentrantReadWriteLock.EndWrite())
{
case ReentrantReadWriteLock.Signaller.READER:
ReentrantReadWriteLock.SignallerReaderLock.SignalWaiters();
break;
case ReentrantReadWriteLock.Signaller.WRITER:
ReentrantReadWriteLock.SignallerWriterLock.SignalWaiters();
break;
default:
break;
}
}
public void Serialization()
{
ReentrantReadWriteLock l = new ReentrantReadWriteLock();
l.ReaderLock.Lock();
l.ReaderLock.Unlock();
MemoryStream bout = new MemoryStream(10000);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(bout, l);
MemoryStream bin = new MemoryStream(bout.ToArray());
BinaryFormatter formatter2 = new BinaryFormatter();
ReentrantReadWriteLock r = (ReentrantReadWriteLock)formatter2.Deserialize(bin);
r.ReaderLock.Lock();
r.ReaderLock.Unlock();
}
/// <summary>
/// Acquires the write lock unless <see cref="System.Threading.Thread.Interrupt()"/> is called on the current thread
/// </summary>
/// <remarks>
/// Acquires the write lock if neither the read nor write locks
/// are held by another thread
/// and returns immediately, setting the write lock hold count to
/// one.
///
/// <p/>
/// If the current thread already holds this lock then the
/// hold count is incremented by one and the method returns
/// immediately.
///
/// <p/>
/// If the lock is held by another thread then the current
/// thread becomes disabled for thread scheduling purposes and
/// lies dormant until one of two things happens:
///
/// <ul>
/// <li>The write lock is acquired by the current thread.</li>
/// <li>Some other thread calls <see cref="System.Threading.Thread.Interrupt()"/> on the current thread.</li>
/// </ul>
///
/// <p/>
/// If the write lock is acquired by the current thread then the
/// lock hold count is set to one.
///
/// <p/>
/// If the current thread:
/// <ul>
/// <li>has its interrupted status set on entry to this method</li>
/// <li><see cref="System.Threading.Thread.Interrupt()"/> is called on the thread while acquiring the write lock.</li>
/// </ul>
///
/// then a <see cref="System.Threading.ThreadInterruptedException"/> is thrown and the current
/// thread's interrupted status is cleared.
///
/// <p/>
/// In this implementation, as this method is an explicit
/// interruption point, preference is given to responding to
/// the interrupt over normal or reentrant acquisition of the
/// lock.
///
/// </remarks>
/// <exception cref="System.Threading.ThreadInterruptedException">if the current thread is interrupted.</exception>
public override IDisposable LockInterruptibly()
{
ThreadInterruptedException ie = null;
lock (this)
{
if (!ReentrantReadWriteLock.StartWriteFromNewWriter())
{
for (;;)
{
try
{
Monitor.Wait(this);
if (ReentrantReadWriteLock.StartWriteFromWaitingWriter())
{
return(this);
}
}
catch (ThreadInterruptedException ex)
{
ReentrantReadWriteLock.CancelWaitingWriter();
Monitor.Pulse(this);
ie = ex;
break;
}
}
}
}
if (ie != null)
{
// Fall through outside synch on interrupt.
// On exception, we may need to signal readers.
// It is not worth checking here whether it is strictly necessary.
ReentrantReadWriteLock.SignallerReaderLock.SignalWaiters();
throw ie;
}
return(this);
}
public void Signal_IllegalMonitor()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
try
{
c.Signal();
Assert.Fail("Should throw an exception.");
}
catch (SynchronizationLockException)
{
}
}
public AnonymousClassRunnable24(ReentrantReadWriteLock myLock, ICondition c)
{
this.myLock = myLock;
this.c = c;
}
public void Await_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
myLock.WriterLock.Lock();
myLock.WriterLock.Unlock();
}
public void Constructor()
{
ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
Assert.IsFalse(rl.IsFair);
Assert.IsFalse(rl.IsWriteLockHeld);
Assert.AreEqual(0, rl.ReadLockCount);
}
public void GetWriteHoldCount()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
for (int i = 1; i <= DEFAULT_COLLECTION_SIZE; i++)
{
myLock.WriterLock.Lock();
Assert.AreEqual(i, myLock.WriteHoldCount);
}
for (int i = DEFAULT_COLLECTION_SIZE; i > 0; i--)
{
myLock.WriterLock.Unlock();
Assert.AreEqual(i - 1, myLock.WriteHoldCount);
}
}
public void MultipleReadLocks()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.ReaderLock.Lock();
Thread t = new Thread(new AnonymousClassRunnable6(myLock).Run);
t.Start();
t.Join();
myLock.ReaderLock.Unlock();
}
public void ReadLockToString()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
String us = myLock.ReaderLock.ToString();
Assert.IsTrue(us.IndexOf("Read locks = 0") >= 0);
myLock.ReaderLock.Lock();
myLock.ReaderLock.Lock();
String rs = myLock.ReaderLock.ToString();
Assert.IsTrue(rs.IndexOf("Read locks = 2") >= 0);
}
public void WriteTryLockWhenReadLocked()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.ReaderLock.Lock();
Thread t = new Thread(new AnonymousClassRunnable14(myLock).Run);
t.Start();
t.Join();
myLock.ReaderLock.Unlock();
}
public void WriteTryLock_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.WriterLock.Lock();
Thread t = new Thread(new AnonymousClassRunnable15(myLock).Run);
t.Start();
t.Join();
myLock.WriterLock.Unlock();
}
internal InterruptibleLockRunnable(ReentrantReadWriteLock l)
{
myLock = l;
}
public AnonymousClassRunnable16(ReentrantReadWriteLock myLock)
{
this.myLock = myLock;
}
public void Serialization()
{
ReentrantReadWriteLock l = new ReentrantReadWriteLock();
l.ReaderLock.Lock();
l.ReaderLock.Unlock();
MemoryStream bout = new MemoryStream(10000);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(bout, l);
MemoryStream bin = new MemoryStream(bout.ToArray());
BinaryFormatter formatter2 = new BinaryFormatter();
ReentrantReadWriteLock r = (ReentrantReadWriteLock) formatter2.Deserialize(bin);
r.ReaderLock.Lock();
r.ReaderLock.Unlock();
}
public void ReadTryLock_Interrupted()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.WriterLock.Lock();
Thread t = new Thread(new AnonymousClassRunnable3(myLock).Run);
t.Start();
t.Interrupt();
t.Join();
}
public void WriteLockToString()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
String us = myLock.WriterLock.ToString();
Assert.IsTrue(us.IndexOf("Unlocked") >= 0);
myLock.WriterLock.Lock();
String ls = myLock.WriterLock.ToString();
Assert.IsTrue(ls.IndexOf("Locked") >= 0);
}
public void ReadHoldingWriterLock()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.WriterLock.Lock();
Assert.IsTrue(myLock.ReaderLock.TryLock());
myLock.ReaderLock.Unlock();
myLock.WriterLock.Unlock();
}
public void WriteLockInterruptibly_Interrupted()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
Thread t = new Thread(new AnonymousClassRunnable(myLock).Run);
myLock.WriterLock.Lock();
t.Start();
Thread.Sleep(Delays.Short);
t.Interrupt();
Thread.Sleep(Delays.Short);
myLock.WriterLock.Unlock();
t.Join();
}
public void Lock()
{
ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
rl.WriterLock.Lock();
Assert.IsTrue(rl.IsWriteLockHeld);
Assert.IsTrue(rl.WriterLockedByCurrentThread);
// assertTrue(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
Assert.AreEqual(0, rl.ReadLockCount);
rl.WriterLock.Unlock();
Assert.IsFalse(rl.IsWriteLockHeld);
Assert.IsFalse(rl.WriterLockedByCurrentThread);
// assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
Assert.AreEqual(0, rl.ReadLockCount);
rl.ReaderLock.Lock();
Assert.IsFalse(rl.IsWriteLockHeld);
Assert.IsFalse(rl.WriterLockedByCurrentThread);
// assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
Assert.AreEqual(1, rl.ReadLockCount);
rl.ReaderLock.Unlock();
Assert.IsFalse(rl.IsWriteLockHeld);
Assert.IsFalse(rl.WriterLockedByCurrentThread);
// assertFalse(((ReentrantReadWriteLock.WriteLock)rl.writeLock()).isHeldByCurrentThread());
Assert.AreEqual(0, rl.ReadLockCount);
}
public void WriteAfterMultipleReadLocks()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
myLock.ReaderLock.Lock();
Thread t1 = new Thread(new AnonymousClassRunnable7(myLock).Run);
Thread t2 = new Thread(new AnonymousClassRunnable8(myLock).Run);
t1.Start();
t2.Start();
Thread.Sleep(new TimeSpan(Delays.Short.Milliseconds*10000));
myLock.ReaderLock.Unlock();
t1.Join(Delays.Medium);
t2.Join(Delays.Medium);
Assert.IsTrue(!t1.IsAlive);
Assert.IsTrue(!t2.IsAlive);
}
public void GetQueueLength()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
Thread t1 = new Thread(new InterruptedLockRunnable(myLock).Run);
Thread t2 = new Thread(new InterruptibleLockRunnable(myLock).Run);
Assert.AreEqual(0, myLock.QueueLength);
myLock.WriterLock.Lock();
t1.Start();
Thread.Sleep(new TimeSpan(10000*Delays.Short.Milliseconds));
Assert.AreEqual(1, myLock.QueueLength);
t2.Start();
Thread.Sleep(new TimeSpan(10000*Delays.Short.Milliseconds));
Assert.AreEqual(2, myLock.QueueLength);
t1.Interrupt();
Thread.Sleep(new TimeSpan(10000*Delays.Short.Milliseconds));
Assert.AreEqual(1, myLock.QueueLength);
myLock.WriterLock.Unlock();
Thread.Sleep(new TimeSpan(10000*Delays.Short.Milliseconds));
Assert.AreEqual(0, myLock.QueueLength);
t1.Join();
t2.Join();
}
public void Unlock_IllegalMonitorStateException()
{
ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
try
{
rl.WriterLock.Unlock();
Assert.Fail("Should throw an exception.");
}
catch (SynchronizationLockException)
{
}
}
public AnonymousClassRunnable3(ReentrantReadWriteLock myLock)
{
this.myLock = myLock;
}
internal InterruptedLockRunnable(ReentrantReadWriteLock l)
{
myLock = l;
}
public void ToStringTest()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
String us = myLock.ToString();
Assert.IsTrue(us.IndexOf("Write locks = 0") >= 0);
Assert.IsTrue(us.IndexOf("Read locks = 0") >= 0);
myLock.WriterLock.Lock();
String ws = myLock.ToString();
Assert.IsTrue(ws.IndexOf("Write locks = 1") >= 0);
Assert.IsTrue(ws.IndexOf("Read locks = 0") >= 0);
myLock.WriterLock.Unlock();
myLock.ReaderLock.Lock();
myLock.ReaderLock.Lock();
String rs = myLock.ToString();
Assert.IsTrue(rs.IndexOf("Write locks = 0") >= 0);
Assert.IsTrue(rs.IndexOf("Read locks = 2") >= 0);
}
/// <summary>
/// Constructs a <see cref="Spring.Threading.Locks.WriterLock"/>, using the given <see cref="Spring.Threading.Locks.ReentrantReadWriteLock"/>
/// </summary>
/// <param name="reentrantReadWriteLock"><see cref="Spring.Threading.Locks.ReentrantReadWriteLock"/> to use for this lock.</param>
public WriterLock(ReentrantReadWriteLock reentrantReadWriteLock)
: base(reentrantReadWriteLock)
{
}
protected AbstractSignallerLock(ReentrantReadWriteLock reentrantReadWriteLock)
{
_reentrantReadWriteLock = reentrantReadWriteLock;
}
public void AwaitUntil_Timeout()
{
ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
ICondition c = myLock.WriterLock.NewCondition();
myLock.WriterLock.Lock();
DateTime d = DateTime.Now;
myLock.WriterLock.Unlock();
}
