bool RunAllTasks(PreciseTimeSpan timeout)
{
this.FetchFromScheduledTaskQueue();
IRunnable task = this.PollTask();
if (task == null)
{
return(false);
}
PreciseTimeSpan deadline = PreciseTimeSpan.Deadline(timeout);
long runTasks = 0;
PreciseTimeSpan executionTime;
while (true)
{
try
{
task.Run();
}
catch (Exception ex)
{
//Logger.Warn("A task raised an exception.", ex);
}
runTasks++;
if ((runTasks & 0x3F) == 0)
{
executionTime = PreciseTimeSpan.FromStart;
if (executionTime >= deadline)
{
break;
}
}
task = this.PollTask();
if (task == null)
{
executionTime = PreciseTimeSpan.FromStart;
break;
}
}
this.lastExecutionTime = executionTime;
return(true);
}
bool FetchFromScheduledTaskQueue()
{
PreciseTimeSpan nanoTime = PreciseTimeSpan.FromStart;
IScheduledRunnable scheduledTask = this.PollScheduledTask(nanoTime);
while (scheduledTask != null)
{
if (!this.taskQueue.TryEnqueue(scheduledTask))
{
// No space left in the task queue add it back to the scheduledTaskQueue so we pick it up again.
this.ScheduledTaskQueue.Enqueue(scheduledTask);
return(false);
}
scheduledTask = this.PollScheduledTask(nanoTime);
}
return(true);
}
protected IndependentThreadExecutor(IExecutorGroup parent, string threadName, TimeSpan breakoutInterval, IConcurrentQueue <IRunnable> taskQueue)
: base(parent)
{
this.terminationCompletionSource = new TaskCompletionSource();
this.taskQueue = taskQueue;
this.preciseBreakoutInterval = PreciseTimeSpan.FromTimeSpan(breakoutInterval);
this.scheduler = new ExecutorTaskScheduler(this);
this.thread = new Thread(this.Loop);
if (string.IsNullOrEmpty(threadName))
{
this.thread.Name = DefaultWorkerThreadName;
}
else
{
this.thread.Name = threadName;
}
this.thread.Start();
}
protected ScheduledAsyncTask(Executor executor, PreciseTimeSpan deadline, TaskCompletionSource promise, CancellationToken cancellationToken)
: base(executor, deadline, promise)
{
this.cancellationToken = cancellationToken;
this.cancellationTokenRegistration = cancellationToken.Register(s => ((ScheduledAsyncTask)s).Cancel(), this);
}
public RunnableScheduledTask(Executor executor, IRunnable action, PreciseTimeSpan deadline)
: base(executor, deadline, new TaskCompletionSource())
{
this.action = action;
}
public ActionScheduledAsyncTask(Executor executor, Action action, PreciseTimeSpan deadline, CancellationToken cancellationToken)
: base(executor, deadline, new TaskCompletionSource(), cancellationToken)
{
this.action = action;
}
public StateActionScheduledAsyncTask(Executor executor, Action <object> action, object state, PreciseTimeSpan deadline,
CancellationToken cancellationToken)
: base(executor, deadline, new TaskCompletionSource(state), cancellationToken)
{
this.action = action;
}
public StateActionScheduledTask(Executor executor, Action <object> action, object state, PreciseTimeSpan deadline)
: base(executor, deadline, new TaskCompletionSource(state))
{
this.action = action;
}
/// <inheritdoc cref="IEventExecutor"/>
public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan timeout)
{
Contract.Requires(quietPeriod >= TimeSpan.Zero);
Contract.Requires(timeout >= quietPeriod);
if (this.IsShuttingDown)
{
return(this.TerminationCompletion);
}
bool inEventLoop = this.InLoop;
bool wakeup;
int oldState;
while (true)
{
if (this.IsShuttingDown)
{
return(this.TerminationCompletion);
}
int newState;
wakeup = true;
oldState = this.executionState;
if (inEventLoop)
{
newState = ST_SHUTTING_DOWN;
}
else
{
switch (oldState)
{
case ST_NOT_STARTED:
case ST_STARTED:
newState = ST_SHUTTING_DOWN;
break;
default:
newState = oldState;
wakeup = false;
break;
}
}
if (Interlocked.CompareExchange(ref this.executionState, newState, oldState) == oldState)
{
break;
}
}
this.gracefulShutdownQuietPeriod = PreciseTimeSpan.FromTimeSpan(quietPeriod);
this.gracefulShutdownTimeout = PreciseTimeSpan.FromTimeSpan(timeout);
// todo: revisit
//if (oldState == ST_NOT_STARTED)
//{
// scheduleExecution();
//}
if (wakeup)
{
this.WakeUp(inEventLoop);
}
return(this.TerminationCompletion);
}
public virtual Task ScheduleAsync(Action <object, object> action, object context, object state, TimeSpan delay, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(TaskEx.Cancelled);
}
if (!cancellationToken.CanBeCanceled)
{
return(this.Schedule(action, context, state, delay).Completion);
}
return(this.Schedule(new StateWithContextScheduledAsyncTask(this, action, context, state, PreciseTimeSpan.Deadline(delay), cancellationToken)).Completion);
}
public virtual IScheduledTask Schedule(Action <object, object> action, object context, object state, TimeSpan delay)
{
Require.NotNull(action);
return(this.Schedule(new StateActionWithContextScheduledTask(this, action, context, state, PreciseTimeSpan.Deadline(delay))));
}
public virtual IScheduledTask Schedule(Action action, TimeSpan delay)
{
Require.NotNull(action);
return(this.Schedule(new ActionScheduledTask(this, action, PreciseTimeSpan.Deadline(delay))));
}
protected ScheduledTask(Executor executor, PreciseTimeSpan deadline, TaskCompletionSource promise)
{
this.Executor = executor;
this.Promise = promise;
this.Deadline = deadline;
}
