/// <summary>
/// Gets the next scheduled item to be executed.
/// </summary>
/// <returns>The next scheduled item.</returns>
protected override IScheduledItem <TAbsolute> GetNext()
{
while (queue.Count > 0)
{
var next = queue.Peek();
if (next.IsCanceled)
{
queue.Dequeue();
}
else
{
return(next);
}
}
return(null);
}
/// <summary>
/// Gets the next scheduled item to be executed.
/// </summary>
/// <returns>The next scheduled item.</returns>
protected override IScheduledItem <DateTimeOffset> GetNext()
{
while (_queue.Count > 0)
{
var next = _queue.Peek();
if (next.IsCanceled)
{
_queue.Dequeue();
}
else
{
return(next);
}
}
return(null);
}
/// <summary>
/// Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event
/// which gets set by calls to Schedule, the next item timer, or calls to Dispose.
/// </summary>
private void Run()
{
while (true)
{
_evt.Wait();
var ready = default(ScheduledItem <TimeSpan>[]);
lock (_gate)
{
//
// Bug fix that ensures the number of calls to Release never greatly exceeds the number of calls to Wait.
// See work item #37: https://rx.codeplex.com/workitem/37
//
while (_evt.CurrentCount > 0)
{
_evt.Wait();
}
//
// The event could have been set by a call to Dispose. This takes priority over anything else. We quit the
// loop immediately. Subsequent calls to Schedule won't ever create a new thread.
//
if (_disposed)
{
((IDisposable)_evt).Dispose();
return;
}
while (_queue.Count > 0 && _queue.Peek().DueTime <= _stopwatch.Elapsed)
{
var item = _queue.Dequeue();
_readyList.Enqueue(item);
}
if (_queue.Count > 0)
{
var next = _queue.Peek();
if (next != _nextItem)
{
_nextItem = next;
var due = next.DueTime - _stopwatch.Elapsed;
_nextTimer.Disposable = ConcurrencyAbstractionLayer.Current.StartTimer(Tick, next, due);
}
}
if (_readyList.Count > 0)
{
ready = _readyList.ToArray();
_readyList.Clear();
}
}
if (ready != null)
{
foreach (var item in ready)
{
if (!item.IsCanceled)
{
item.Invoke();
}
}
}
if (ExitIfEmpty)
{
lock (_gate)
{
if (_readyList.Count == 0 && _queue.Count == 0)
{
_thread = null;
return;
}
}
}
}
}
/// <summary>
/// Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event
/// which gets set by calls to Schedule, the next item timer, or calls to Dispose.
/// </summary>
private void Run()
{
while (true)
{
_evt.Wait();
var ready = default(ScheduledItem <TimeSpan>[]);
lock (_gate)
{
//
// Bug fix that ensures the number of calls to Release never greatly exceeds the number of calls to Wait.
// See work item #37: https://rx.codeplex.com/workitem/37
//
while (_evt.CurrentCount > 0)
{
_evt.Wait();
}
//
// The event could have been set by a call to Dispose. This takes priority over anything else. We quit the
// loop immediately. Subsequent calls to Schedule won't ever create a new thread.
//
if (_disposed)
{
_evt.Dispose();
return;
}
while (_queue.Count > 0 && _queue.Peek().DueTime <= _stopwatch.Elapsed)
{
var item = _queue.Dequeue();
_readyList.Enqueue(item);
}
if (_queue.Count > 0)
{
var next = _queue.Peek();
if (next != _nextItem)
{
_nextItem = next;
var due = next.DueTime - _stopwatch.Elapsed;
Disposable.TrySetSerial(ref _nextTimer, ConcurrencyAbstractionLayer.Current.StartTimer(Tick, next, due));
}
}
if (_readyList.Count > 0)
{
ready = _readyList.ToArray();
_readyList.Clear();
}
}
if (ready != null)
{
foreach (var item in ready)
{
if (!item.IsCanceled)
{
try
{
item.Invoke();
}
catch (ObjectDisposedException ex) when(nameof(EventLoopScheduler).Equals(ex.ObjectName))
{
// Since we are not inside the lock at this point
// the scheduler can be disposed before the item had a chance to run
}
}
}
}
if (ExitIfEmpty)
{
lock (_gate)
{
if (_readyList.Count == 0 && _queue.Count == 0)
{
_thread = null;
return;
}
}
}
}
}
/// <summary>
/// Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event
/// which gets set by calls to Schedule, the next item timer, or calls to Dispose.
/// </summary>
private void Run()
{
while (true)
{
#if !NO_CDS
_evt.Wait();
#else
_evt.WaitOne();
#endif
var ready = default(ScheduledItem <SafeTimeSpan>[]);
lock (_gate)
{
//
// The event could have been set by a call to Dispose. This takes priority over anything else. We quit the
// loop immediately. Subsequent calls to Schedule won't ever create a new thread.
//
if (_disposed)
{
((IDisposable)_evt).Dispose();
return;
}
while (_queue.Count > 0 && (TimeSpan)_queue.Peek().DueTime <= _stopwatch.Elapsed)
{
var item = _queue.Dequeue();
_readyList.Enqueue(item);
}
if (_queue.Count > 0)
{
var next = _queue.Peek();
if (next != _nextItem)
{
_nextItem = next;
var due = (TimeSpan)next.DueTime - _stopwatch.Elapsed;
_nextTimer.Disposable = ConcurrencyAbstractionLayer.Current.StartTimer(Tick, next, due);
}
}
if (_readyList.Count > 0)
{
ready = _readyList.ToArray();
_readyList.Clear();
}
}
if (ready != null)
{
foreach (var item in ready)
{
if (!item.IsCanceled)
{
item.Invoke();
}
}
}
if (ExitIfEmpty)
{
lock (_gate)
{
if (_readyList.Count == 0 && _queue.Count == 0)
{
_thread = null;
return;
}
}
}
}
}