Browse Source

Added a SingleThreadTaskScheduler

4.0.0-beta
Anairkoen Schno 5 years ago
parent
commit
aca59e8d86
2 changed files with 176 additions and 0 deletions
  1. +1
    -0
      IPA.Loader/IPA.Loader.csproj
  2. +175
    -0
      IPA.Loader/Utilities/Async/SingleThreadTaskScheduler.cs

+ 1
- 0
IPA.Loader/IPA.Loader.csproj View File

@ -127,6 +127,7 @@
<Compile Include="Config\ModPrefs.cs" />
<Compile Include="JsonConverters\SemverRangeConverter.cs" />
<Compile Include="JsonConverters\SemverVersionConverter.cs" />
<Compile Include="Utilities\Async\SingleThreadTaskScheduler.cs" />
<Compile Include="Utilities\BeatSaber.cs" />
<Compile Include="Utilities\AlmostVersion.cs" />
<Compile Include="Utilities\CriticalSection.cs" />


+ 175
- 0
IPA.Loader/Utilities/Async/SingleThreadTaskScheduler.cs View File

@ -0,0 +1,175 @@
using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace IPA.Utilities.Async
{
/// <summary>
/// A single-threaded task scheduler that runs all of its tasks on the same thread.
/// </summary>
public class SingleThreadTaskScheduler : TaskScheduler, IDisposable
{
private readonly Thread runThread = new Thread(ExecuteTasksS);
private readonly BlockingCollection<Task> tasks = new BlockingCollection<Task>();
private readonly CancellationTokenSource exitTokenSource = new CancellationTokenSource();
/// <summary>
/// Starts the thread that executes tasks scheduled with this <see cref="TaskScheduler"/>
/// </summary>
/// <exception cref="InvalidOperationException">Thrown if this object has already been disposed.</exception>
public void StartThread()
{
ThrowIfDisposed();
runThread.Start();
}
/// <summary>
/// Terminates the runner thread, and waits for the currently running task to complete.
/// </summary>
/// <remarks>
/// After this method returns, this object has been disposed and is no longer in a valid state.
/// </remarks>
/// <returns>an <see cref="IEnumerable{T}"/> of <see cref="Task"/>s that did not execute</returns>
/// <exception cref="InvalidOperationException">Thrown if this object has already been disposed.</exception>
public IEnumerable<Task> Exit()
{
ThrowIfDisposed();
tasks.CompleteAdding();
exitTokenSource.Cancel();
runThread.Join();
var retTasks = new List<Task>();
retTasks.AddRange(tasks);
Dispose(true);
return retTasks;
}
/// <summary>
/// Waits for the runner thread to complete all tasks in the queue, then exits.
/// </summary>
/// <remarks>
/// After this method returns, this object has been disposed and is no longer in a valid state.
/// </remarks>
/// <exception cref="InvalidOperationException">Thrown if this object has already been disposed.</exception>
public void Join()
{
ThrowIfDisposed();
tasks.CompleteAdding();
runThread.Join();
Dispose(true);
}
/// <summary>
/// Throws a <see cref="NotSupportedException"/>.
/// </summary>
/// <returns>nothing</returns>
/// <exception cref="NotSupportedException">Always.</exception>
protected override IEnumerable<Task> GetScheduledTasks()
{
// this is only for debuggers which we can't use sooooo
throw new NotSupportedException();
}
/// <summary>
/// Queues a given <see cref="Task"/> to this scheduler. The <see cref="Task"/> <i>must></i> be
/// scheduled for this <see cref="TaskScheduler"/> by the runtime.
/// </summary>
/// <param name="task">the <see cref="Task"/> to queue</param>
/// <exception cref="InvalidOperationException">Thrown if this object has already been disposed.</exception>
protected override void QueueTask(Task task)
{
ThrowIfDisposed();
tasks.Add(task);
}
/// <summary>
/// Rejects any attempts to execute a task inline.
/// </summary>
/// <remarks>
/// This task scheduler <i>always</i> runs its tasks on the thread that it manages, therefore it doesn't
/// make sense to run it inline.
/// </remarks>
/// <param name="task">the task to attempt to execute</param>
/// <param name="taskWasPreviouslyQueued">whether the task was previously queued to this scheduler</param>
/// <returns><see langword="false"/></returns>
/// <exception cref="InvalidOperationException">Thrown if this object has already been disposed.</exception>
protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
{
ThrowIfDisposed();
return false;
}
private void ThrowIfDisposed()
{
if (disposedValue)
throw new InvalidOperationException("Object already disposed");
}
private void ExecuteTasks()
{
ThrowIfDisposed();
var token = exitTokenSource.Token;
try
{
// while we are still accepting tasks, and we can pull out a task with an infinite wait duration
while (!tasks.IsCompleted && tasks.TryTake(out var task, -1, token))
{
TryExecuteTask(task);
}
}
catch (OperationCanceledException)
{
// TryTake was cancelled, we'll just leave
}
}
private static void ExecuteTasksS(object param)
{
var self = param as SingleThreadTaskScheduler;
self.ExecuteTasks();
}
#region IDisposable Support
private bool disposedValue = false; // To detect redundant calls
/// <summary>
/// Disposes this object.
/// </summary>
/// <param name="disposing">whether or not to dispose managed objects</param>
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
exitTokenSource.Dispose();
tasks.Dispose();
}
disposedValue = true;
}
}
/// <summary>
/// Disposes this object. This puts the object into an unusable state.
/// </summary>
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
}
#endregion
}
}

Loading…
Cancel
Save