RaspberryIO_26/Swan/Threading/ThreadWorkerBase.cs
2019-12-08 21:23:54 +01:00

252 lines
9.5 KiB
C#

namespace Swan.Threading {
using System;
using System.Threading;
using System.Threading.Tasks;
/// <summary>
/// Provides a base implementation for application workers
/// that perform continuous, long-running tasks. This class
/// provides the ability to perform fine-grained control on these tasks.
/// </summary>
/// <seealso cref="IWorker" />
public abstract class ThreadWorkerBase : WorkerBase {
private readonly Object _syncLock = new Object();
private readonly Thread _thread;
/// <summary>
/// Initializes a new instance of the <see cref="ThreadWorkerBase"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="priority">The thread priority.</param>
/// <param name="period">The interval of cycle execution.</param>
/// <param name="delayProvider">The cycle delay provide implementation.</param>
protected ThreadWorkerBase(String name, ThreadPriority priority, TimeSpan period, IWorkerDelayProvider delayProvider) : base(name, period) {
this.DelayProvider = delayProvider;
this._thread = new Thread(this.RunWorkerLoop) {
IsBackground = true,
Priority = priority,
Name = name,
};
}
/// <summary>
/// Initializes a new instance of the <see cref="ThreadWorkerBase"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="period">The execution interval.</param>
protected ThreadWorkerBase(String name, TimeSpan period) : this(name, ThreadPriority.Normal, period, WorkerDelayProvider.Default) {
// placeholder
}
/// <summary>
/// Provides an implementation on a cycle delay provider.
/// </summary>
protected IWorkerDelayProvider DelayProvider {
get;
}
/// <inheritdoc />
public override Task<WorkerState> StartAsync() {
lock(this._syncLock) {
if(this.WorkerState == WorkerState.Paused || this.WorkerState == WorkerState.Waiting) {
return this.ResumeAsync();
}
if(this.WorkerState != WorkerState.Created) {
return Task.FromResult(this.WorkerState);
}
if(this.IsStopRequested) {
return Task.FromResult(this.WorkerState);
}
Task<WorkerState> task = this.QueueStateChange(StateChangeRequest.Start);
this._thread.Start();
return task;
}
}
/// <inheritdoc />
public override Task<WorkerState> PauseAsync() {
lock(this._syncLock) {
return this.WorkerState != WorkerState.Running && this.WorkerState != WorkerState.Waiting ? Task.FromResult(this.WorkerState) : this.IsStopRequested ? Task.FromResult(this.WorkerState) : this.QueueStateChange(StateChangeRequest.Pause);
}
}
/// <inheritdoc />
public override Task<WorkerState> ResumeAsync() {
lock(this._syncLock) {
return this.WorkerState == WorkerState.Created ? this.StartAsync() : this.WorkerState != WorkerState.Paused && this.WorkerState != WorkerState.Waiting ? Task.FromResult(this.WorkerState) : this.IsStopRequested ? Task.FromResult(this.WorkerState) : this.QueueStateChange(StateChangeRequest.Resume);
}
}
/// <inheritdoc />
public override Task<WorkerState> StopAsync() {
lock(this._syncLock) {
if(this.WorkerState == WorkerState.Stopped || this.WorkerState == WorkerState.Created) {
this.WorkerState = WorkerState.Stopped;
return Task.FromResult(this.WorkerState);
}
return this.QueueStateChange(StateChangeRequest.Stop);
}
}
/// <summary>
/// Suspends execution queues a new new cycle for execution. The delay is given in
/// milliseconds. When overridden in a derived class the wait handle will be set
/// whenever an interrupt is received.
/// </summary>
/// <param name="wantedDelay">The remaining delay to wait for in the cycle.</param>
/// <param name="delayTask">Contains a reference to a task with the scheduled period delay.</param>
/// <param name="token">The cancellation token to cancel waiting.</param>
protected virtual void ExecuteCycleDelay(Int32 wantedDelay, Task delayTask, CancellationToken token) =>
this.DelayProvider?.ExecuteCycleDelay(wantedDelay, delayTask, token);
/// <inheritdoc />
protected override void OnDisposing() {
lock(this._syncLock) {
if((this._thread.ThreadState & ThreadState.Unstarted) != ThreadState.Unstarted) {
this._thread.Join();
}
}
}
/// <summary>
/// Implements worker control, execution and delay logic in a loop.
/// </summary>
private void RunWorkerLoop() {
while(this.WorkerState != WorkerState.Stopped && !this.IsDisposing && !this.IsDisposed) {
this.CycleStopwatch.Restart();
CancellationToken interruptToken = this.CycleCancellation.Token;
Int32 period = this.Period.TotalMilliseconds >= Int32.MaxValue ? -1 : Convert.ToInt32(Math.Floor(this.Period.TotalMilliseconds));
Task delayTask = Task.Delay(period, interruptToken);
WorkerState initialWorkerState = this.WorkerState;
// Lock the cycle and capture relevant state valid for this cycle
this.CycleCompletedEvent.Reset();
// Process the tasks that are awaiting
if(this.ProcessStateChangeRequests()) {
continue;
}
try {
if(initialWorkerState == WorkerState.Waiting &&
!interruptToken.IsCancellationRequested) {
// Mark the state as Running
this.WorkerState = WorkerState.Running;
// Call the execution logic
this.ExecuteCycleLogic(interruptToken);
}
} catch(Exception ex) {
this.OnCycleException(ex);
} finally {
// Update the state
this.WorkerState = initialWorkerState == WorkerState.Paused
? WorkerState.Paused
: WorkerState.Waiting;
// Signal the cycle has been completed so new cycles can be executed
this.CycleCompletedEvent.Set();
if(!interruptToken.IsCancellationRequested) {
Int32 cycleDelay = this.ComputeCycleDelay(initialWorkerState);
if(cycleDelay == Timeout.Infinite) {
delayTask = Task.Delay(Timeout.Infinite, interruptToken);
}
this.ExecuteCycleDelay(
cycleDelay,
delayTask,
this.CycleCancellation.Token);
}
}
}
this.ClearStateChangeRequests();
this.WorkerState = WorkerState.Stopped;
}
/// <summary>
/// Queues a transition in worker state for processing. Returns a task that can be awaited
/// when the operation completes.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The awaitable task.</returns>
private Task<WorkerState> QueueStateChange(StateChangeRequest request) {
lock(this._syncLock) {
if(this.StateChangeTask != null) {
return this.StateChangeTask;
}
Task<WorkerState> waitingTask = new Task<WorkerState>(() => {
this.StateChangedEvent.Wait();
lock(this._syncLock) {
this.StateChangeTask = null;
return this.WorkerState;
}
});
this.StateChangeTask = waitingTask;
this.StateChangedEvent.Reset();
this.StateChangeRequests[request] = true;
waitingTask.Start();
this.CycleCancellation.Cancel();
return waitingTask;
}
}
/// <summary>
/// Processes the state change request by checking pending events and scheduling
/// cycle execution accordingly. The <see cref="WorkerState"/> is also updated.
/// </summary>
/// <returns>Returns <c>true</c> if the execution should be terminated. <c>false</c> otherwise.</returns>
private Boolean ProcessStateChangeRequests() {
lock(this._syncLock) {
Boolean hasRequest = false;
WorkerState currentState = this.WorkerState;
// Update the state in the given priority
if(this.StateChangeRequests[StateChangeRequest.Stop] || this.IsDisposing || this.IsDisposed) {
hasRequest = true;
this.WorkerState = WorkerState.Stopped;
} else if(this.StateChangeRequests[StateChangeRequest.Pause]) {
hasRequest = true;
this.WorkerState = WorkerState.Paused;
} else if(this.StateChangeRequests[StateChangeRequest.Start] || this.StateChangeRequests[StateChangeRequest.Resume]) {
hasRequest = true;
this.WorkerState = WorkerState.Waiting;
}
// Signals all state changes to continue
// as a command has been handled.
if(hasRequest) {
this.ClearStateChangeRequests();
this.OnStateChangeProcessed(currentState, this.WorkerState);
}
return hasRequest;
}
}
/// <summary>
/// Signals all state change requests to set.
/// </summary>
private void ClearStateChangeRequests() {
lock(this._syncLock) {
// Mark all events as completed
this.StateChangeRequests[StateChangeRequest.Start] = false;
this.StateChangeRequests[StateChangeRequest.Pause] = false;
this.StateChangeRequests[StateChangeRequest.Resume] = false;
this.StateChangeRequests[StateChangeRequest.Stop] = false;
this.StateChangedEvent.Set();
this.CycleCompletedEvent.Set();
}
}
}
}