public virtual void DoWait(IQueuedSync sync)
{
lock (this)
{
if (!sync.Recheck(this))
{
try
{
while (_waiting)
{
Monitor.Wait(this);
}
}
catch (ThreadInterruptedException ex)
{
if (_waiting)
{
// no notification
_waiting = false; // invalidate for the signaller
throw ex.PreserveStackTrace();
}
// thread was interrupted after it was notified
Thread.CurrentThread.Interrupt();
return;
}
}
}
}
public virtual void DoWaitUninterruptibly(IQueuedSync sync)
{
lock (this)
{
if (!sync.Recheck(this))
{
var wasInterrupted = false;
while (_waiting)
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
wasInterrupted = true;
// no need to notify; if we were signalled, we
// must be not waiting, and we'll act like signalled
}
}
if (wasInterrupted)
{
Thread.CurrentThread.Interrupt();
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sync"></param>
public virtual void DoWaitUninterruptibly(IQueuedSync sync)
{
lock (this)
{
if (!sync.Recheck(this))
{
bool wasInterrupted = false;
while (_waiting)
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
wasInterrupted = true;
}
}
if (wasInterrupted)
{
Thread.CurrentThread.Interrupt();
}
}
}
}
public void SignalOnWaitingThread()
{
WaitNode node = new WaitNode();
IQueuedSync mockQueuedSync = MockRepository.GenerateMock <IQueuedSync>();
node.Signal(mockQueuedSync);
mockQueuedSync.AssertWasCalled(m => m.TakeOver(node));
}
/// <summary>
///
/// </summary>
/// <param name="sync"></param>
/// <param name="duration"></param>
/// <returns></returns>
public virtual bool DoTimedWait(IQueuedSync sync, TimeSpan duration)
{
lock (this)
{
if (sync.Recheck(this) || !_waiting)
{
return(true);
}
else if (duration.Ticks <= 0)
{
_waiting = false;
return(false);
}
else
{
DateTime deadline = DateTime.Now.Add(duration);
try
{
for (;;)
{
Monitor.Wait(this, duration);
if (!_waiting)
{
return(true);
}
else
{
duration = deadline.Subtract(DateTime.Now);
if (duration.Ticks <= 0)
{
_waiting = false;
return(false);
}
}
}
}
catch (ThreadInterruptedException ex)
{
if (_waiting)
{
_waiting = false; // invalidate for the signaller
throw ex;
}
else
{
Thread.CurrentThread.Interrupt();
return(true);
}
}
}
}
}
public virtual bool Signal(IQueuedSync sync)
{
lock (this)
{
var signalled = _waiting;
if (signalled)
{
_waiting = false;
Monitor.Pulse(this);
sync.TakeOver(this);
}
return(signalled);
}
}
public virtual bool Signal(IQueuedSync sync)
{
lock (this)
{
bool signalled = _waiting;
if (signalled)
{
_waiting = false;
Monitor.Pulse(this);
sync.TakeOver(this);
}
return signalled;
}
}
/// <summary>
///
/// </summary>
/// <param name="sync"></param>
/// <param name="duration"></param>
/// <returns></returns>
public virtual bool DoTimedWait( IQueuedSync sync, TimeSpan duration)
{
lock (this)
{
if (sync.Recheck(this) || !_waiting)
{
return true;
}
else if (duration.Ticks <= 0)
{
_waiting = false;
return false;
}
else
{
DateTime deadline = DateTime.Now.Add(duration);
try
{
for (;; )
{
Monitor.Wait(this, duration);
if (!_waiting)
return true;
else
{
duration = deadline.Subtract(DateTime.Now);
if (duration.Ticks <= 0)
{
_waiting = false;
return false;
}
}
}
}
catch (ThreadInterruptedException ex)
{
if (_waiting)
{
_waiting = false; // invalidate for the signaller
throw ex;
}
else
{
Thread.CurrentThread.Interrupt();
return true;
}
}
}
}
}
public virtual bool DoTimedWait(IQueuedSync sync, TimeSpan duration)
{
lock (this)
{
if (sync.Recheck(this) || !_waiting)
{
return(true);
}
if (duration.Ticks <= 0)
{
_waiting = false;
return(false);
}
var deadline = DateTime.UtcNow.Add(duration);
try
{
for (;;)
{
Monitor.Wait(this, duration);
if (!_waiting) // definitely signalled
{
return(true);
}
duration = deadline.Subtract(DateTime.UtcNow);
if (duration.Ticks <= 0) // time out
{
_waiting = false;
return(false);
}
}
}
catch (ThreadInterruptedException ex)
{
if (_waiting) // no notification
{
_waiting = false; // invalidate for the signaller
throw ex.PreserveStackTrace();
}
// thread was interrupted after it was notified
Thread.CurrentThread.Interrupt();
return(true);
}
}
}
public virtual bool DoTimedWait( IQueuedSync sync, TimeSpan duration)
{
lock (this)
{
if (sync.Recheck(this) || !_waiting)
{
return true;
}
if (duration.Ticks <= 0)
{
_waiting = false;
return false;
}
DateTime deadline = DateTime.UtcNow.Add(duration);
try
{
for (;; )
{
Monitor.Wait(this, duration);
if (!_waiting) // definitely signalled
return true;
duration = deadline.Subtract(DateTime.UtcNow);
if (duration.Ticks <= 0) // time out
{
_waiting = false;
return false;
}
}
}
catch (ThreadInterruptedException ex)
{
if (_waiting) // no notification
{
_waiting = false; // invalidate for the signaller
throw SystemExtensions.PreserveStackTrace(ex);
}
// thread was interrupted after it was notified
Thread.CurrentThread.Interrupt();
return true;
}
}
}
public virtual void DoWaitUninterruptibly(IQueuedSync sync)
{
lock (this)
{
if (!sync.Recheck(this))
{
bool wasInterrupted = false;
while (_waiting)
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
wasInterrupted = true;
// no need to notify; if we were signalled, we
// must be not waiting, and we'll act like signalled
}
}
if (wasInterrupted)
{
Thread.CurrentThread.Interrupt();
}
}
}
}
public virtual void DoWait(IQueuedSync sync)
{
lock (this)
{
if (!sync.Recheck(this))
{
try
{
while (_waiting) Monitor.Wait(this);
}
catch (ThreadInterruptedException ex)
{
if (_waiting)
{
// no notification
_waiting = false; // invalidate for the signaller
throw SystemExtensions.PreserveStackTrace(ex);
}
// thread was interrupted after it was notified
Thread.CurrentThread.Interrupt();
return;
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sync"></param>
public virtual void DoWaitUninterruptibly(IQueuedSync sync)
{
lock (this)
{
if (!sync.Recheck(this))
{
bool wasInterrupted = false;
while (_waiting)
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
wasInterrupted = true;
}
}
if (wasInterrupted)
{
Thread.CurrentThread.Interrupt();
}
}
}
}
