タイムアウトでタスク<T>が完了するのを非同期的に待つ
いくつかの特別な規則で Task <T> が完了するのを待ちます。Xミリ秒後に完了しない場合は、ユーザーにメッセージを表示します。そしてそれがYミリ秒後に完了しないならば、私は自動的にしたいです キャンセル要求 。
Task.ContinueWith を使用して、タスクの完了を非同期的に待つ（つまり、タスクが完了したときに実行されるアクションをスケジュールする）ことはできますが、タイムアウトを指定することはできません。タスクがタイムアウトで完了するのを同期的に待つために Task.Wait を使うことができますが、それは私のスレッドをブロックします。タイムアウトでタスクが完了するのを非同期的に待つにはどうすればよいですか。
これはどう：
int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
// task completed within timeout
} else {
// timeout logic
}
そしてこれが MS Parallel Libraryチームからの "Task.TimeoutAfterメソッドの作成"という素晴らしいブログ記事です 。
追加：私の答えに対するコメントを求めて、ここにキャンセル処理を含む拡張ソリューションがあります。タスクとタイマーにキャンセルを渡すことは、コード内でキャンセルを経験することができる複数の方法があることを意味しているので、それらすべてを正しくテストして適切に処理するようにしてください。さまざまな組み合わせをしないでください。また、実行時にコンピュータが正しいことを実行するようにしてください。
int timeout = 1000;
var task = SomeOperationAsync(cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) == task)
{
// Task completed within timeout.
// Consider that the task may have faulted or been canceled.
// We re-await the task so that any exceptions/cancellation is rethrown.
await task;
}
else
{
// timeout/cancellation logic
}
これは、Andrew Arnottが 彼の答え へのコメントで示唆したように、元のタスクが完了したときのタイムアウトのキャンセルを組み込んだ拡張メソッドバージョンです。
public static async Task<TResult> TimeoutAfter<TResult>(this Task<TResult> task, TimeSpan timeout) {
using (var timeoutCancellationTokenSource = new CancellationTokenSource()) {
var completedTask = await Task.WhenAny(task, Task.Delay(timeout, timeoutCancellationTokenSource.Token));
if (completedTask == task) {
timeoutCancellationTokenSource.Cancel();
return await task; // Very important in order to propagate exceptions
} else {
throw new TimeoutException("The operation has timed out.");
}
}
}
Task.WaitAnyを使用して、複数のタスクのうち最初のタスクを待つことができます。
2つの追加タスク（指定されたタイムアウト後に完了する）を作成してから、WaitAnyを使用して、どちらか早いほうが完了するまで待機することができます。最初に完了したタスクがあなたの「仕事」タスクであれば、それで完了です。最初に完了したタスクがタイムアウトタスクである場合は、タイムアウトに反応することができます（例：要求のキャンセル）。
このようなものはどうですか？
const int x = 3000;
const int y = 1000;
static void Main(string[] args)
{
// Your scheduler
TaskScheduler scheduler = TaskScheduler.Default;
Task nonblockingTask = new Task(() =>
{
CancellationTokenSource source = new CancellationTokenSource();
Task t1 = new Task(() =>
{
while (true)
{
// Do something
if (source.IsCancellationRequested)
break;
}
}, source.Token);
t1.Start(scheduler);
// Wait for task 1
bool firstTimeout = t1.Wait(x);
if (!firstTimeout)
{
// If it hasn't finished at first timeout display message
Console.WriteLine("Message to user: the operation hasn't completed yet.");
bool secondTimeout = t1.Wait(y);
if (!secondTimeout)
{
source.Cancel();
Console.WriteLine("Operation stopped!");
}
}
});
nonblockingTask.Start();
Console.WriteLine("Do whatever you want...");
Console.ReadLine();
}
別のタスクを使用してメインスレッドをブロックせずにTask.Waitオプションを使用できます。
これは上の投票された答えに基づいて、完全に機能した例です。
int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
// task completed within timeout
} else {
// timeout logic
}
この回答の実装の主な利点は、総称が追加されていることです。そのため、関数（またはタスク）は値を返すことができます。これは、既存の関数をタイムアウト関数でラップできることを意味します。例えば：
前：
int x = MyFunc();
後：
// Throws a TimeoutException if MyFunc takes more than 1 second
int x = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));
このコードには.NET 4.5が必要です。
using System;
using System.Threading;
using System.Threading.Tasks;
namespace TaskTimeout
{
public static class Program
{
/// <summary>
/// Demo of how to wrap any function in a timeout.
/// </summary>
private static void Main(string[] args)
{
// Version without timeout.
int a = MyFunc();
Console.Write("Result: {0}\n", a);
// Version with timeout.
int b = TimeoutAfter(() => { return MyFunc(); },TimeSpan.FromSeconds(1));
Console.Write("Result: {0}\n", b);
// Version with timeout (short version that uses method groups).
int c = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));
Console.Write("Result: {0}\n", c);
// Version that lets you see what happens when a timeout occurs.
try
{
int d = TimeoutAfter(
() =>
{
Thread.Sleep(TimeSpan.FromSeconds(123));
return 42;
},
TimeSpan.FromSeconds(1));
Console.Write("Result: {0}\n", d);
}
catch (TimeoutException e)
{
Console.Write("Exception: {0}\n", e.Message);
}
// Version that works on tasks.
var task = Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(1));
return 42;
});
// To use async/await, add "await" and remove "GetAwaiter().GetResult()".
var result = task.TimeoutAfterAsync(TimeSpan.FromSeconds(2)).
GetAwaiter().GetResult();
Console.Write("Result: {0}\n", result);
Console.Write("[any key to exit]");
Console.ReadKey();
}
public static int MyFunc()
{
return 42;
}
public static TResult TimeoutAfter<TResult>(
this Func<TResult> func, TimeSpan timeout)
{
var task = Task.Run(func);
return TimeoutAfterAsync(task, timeout).GetAwaiter().GetResult();
}
private static async Task<TResult> TimeoutAfterAsync<TResult>(
this Task<TResult> task, TimeSpan timeout)
{
var result = await Task.WhenAny(task, Task.Delay(timeout));
if (result == task)
{
// Task completed within timeout.
return task.GetAwaiter().GetResult();
}
else
{
// Task timed out.
throw new TimeoutException();
}
}
}
}
警告
この答えを与えたので、絶対にあなたが絶対にしなければならないのでなければ、通常の操作の間にあなたのコードで例外を投げることは一般的にしない良い習慣です：
- 例外がスローされるたびに、非常に重い操作になります。
- 例外が緊密なループにある場合、例外によってコードが100倍以上遅くなる可能性があります。
呼び出している関数を絶対に変更できない場合にのみこのコードを使用して、特定のTimeSpanの後でタイムアウトになるようにします。
この回答は、タイムアウトパラメータを含めるようにリファクタリングすることができないというサードパーティのライブラリライブラリを扱う場合にのみ当てはまります。
堅牢なコードの書き方
堅牢なコードを書きたい場合、一般的な規則はこれです：
無期限にブロックされる可能性があるすべての単一操作には、タイムアウトが必要です。
あなたがこの規則を守らない場合、あなたのコードは何らかの理由で失敗する操作を最終的にヒットし、そしてそれは無期限にブロックします、そしてあなたのアプリは永久にハングしました。
しばらくしても妥当なタイムアウトが発生した場合、アプリは極端な時間（たとえば30秒）の間ハングし、エラーが表示されて元の状態に戻るか、再試行します。
メッセージと自動キャンセルを処理するには、 Timer を使用します。タスクが完了したら、タイマーが破棄されないようにDisposeを呼び出します。これが例です。さまざまなケースを確認するには、taskDelayを500、1500、または2500に変更します。
using System;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class Program
{
private static Task CreateTaskWithTimeout(
int xDelay, int yDelay, int taskDelay)
{
var cts = new CancellationTokenSource();
var token = cts.Token;
var task = Task.Factory.StartNew(() =>
{
// Do some work, but fail if cancellation was requested
token.WaitHandle.WaitOne(taskDelay);
token.ThrowIfCancellationRequested();
Console.WriteLine("Task complete");
});
var messageTimer = new Timer(state =>
{
// Display message at first timeout
Console.WriteLine("X milliseconds elapsed");
}, null, xDelay, -1);
var cancelTimer = new Timer(state =>
{
// Display message and cancel task at second timeout
Console.WriteLine("Y milliseconds elapsed");
cts.Cancel();
}
, null, yDelay, -1);
task.ContinueWith(t =>
{
// Dispose the timers when the task completes
// This will prevent the message from being displayed
// if the task completes before the timeout
messageTimer.Dispose();
cancelTimer.Dispose();
});
return task;
}
static void Main(string[] args)
{
var task = CreateTaskWithTimeout(1000, 2000, 2500);
// The task has been started and will display a message after
// one timeout and then cancel itself after the second
// You can add continuations to the task
// or wait for the result as needed
try
{
task.Wait();
Console.WriteLine("Done waiting for task");
}
catch (AggregateException ex)
{
Console.WriteLine("Error waiting for task:");
foreach (var e in ex.InnerExceptions)
{
Console.WriteLine(e);
}
}
}
}
}
また、 Async CTP はあなたのためにタスクのタイマーをラップするTaskEx.Delayメソッドを提供します。これにより、Timerが起動したときにTaskSchedulerを継続のために設定するなどの操作をより細かく制御できます。
private static Task CreateTaskWithTimeout(
int xDelay, int yDelay, int taskDelay)
{
var cts = new CancellationTokenSource();
var token = cts.Token;
var task = Task.Factory.StartNew(() =>
{
// Do some work, but fail if cancellation was requested
token.WaitHandle.WaitOne(taskDelay);
token.ThrowIfCancellationRequested();
Console.WriteLine("Task complete");
});
var timerCts = new CancellationTokenSource();
var messageTask = TaskEx.Delay(xDelay, timerCts.Token);
messageTask.ContinueWith(t =>
{
// Display message at first timeout
Console.WriteLine("X milliseconds elapsed");
}, TaskContinuationOptions.OnlyOnRanToCompletion);
var cancelTask = TaskEx.Delay(yDelay, timerCts.Token);
cancelTask.ContinueWith(t =>
{
// Display message and cancel task at second timeout
Console.WriteLine("Y milliseconds elapsed");
cts.Cancel();
}, TaskContinuationOptions.OnlyOnRanToCompletion);
task.ContinueWith(t =>
{
timerCts.Cancel();
});
return task;
}
Stephen Clearyの優れた AsyncEx ライブラリを使うと、次のことができます。
TimeSpan timeout = TimeSpan.FromSeconds(10);
using (var cts = new CancellationTokenSource(timeout))
{
await myTask.WaitAsync(cts.Token);
}
タイムアウトの場合はTaskCanceledExceptionがスローされます。
この問題を解決するもう1つの方法は、Reactive Extensionsを使うことです。
public static Task TimeoutAfter(this Task task, TimeSpan timeout, IScheduler scheduler)
{
return task.ToObservable().Timeout(timeout, scheduler).ToTask();
}
あなたのユニットテストで以下のコードを使用して上記のテストをしてください。
TestScheduler scheduler = new TestScheduler();
Task task = Task.Run(() =>
{
int i = 0;
while (i < 5)
{
Console.WriteLine(i);
i++;
Thread.Sleep(1000);
}
})
.TimeoutAfter(TimeSpan.FromSeconds(5), scheduler)
.ContinueWith(t => { }, TaskContinuationOptions.OnlyOnFaulted);
scheduler.AdvanceBy(TimeSpan.FromSeconds(6).Ticks);
次の名前空間が必要になるかもしれません。
using System.Threading.Tasks;
using System.Reactive.Subjects;
using System.Reactive.Linq;
using System.Reactive.Threading.Tasks;
using Microsoft.Reactive.Testing;
using System.Threading;
using System.Reactive.Concurrency;
Reactive Extensionsを使った上記の@ Kevanの回答の一般的なバージョン。
public static Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout, IScheduler scheduler)
{
return task.ToObservable().Timeout(timeout, scheduler).ToTask();
}
オプションのスケジューラの場合：
public static Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout, Scheduler scheduler = null)
{
return scheduler == null
? task.ToObservable().Timeout(timeout).ToTask()
: task.ToObservable().Timeout(timeout, scheduler).ToTask();
}
ところで：タイムアウトが発生すると、タイムアウト例外がスローされます
Andrew Arnottの答えのいくつかの変形：
既存のタスクを待ち、それが完了したかタイムアウトしたかを調べたいが、タイムアウトが発生した場合はキャンセルしたくない場合
public static async Task<bool> TimedOutAsync(this Task task, int timeoutMilliseconds) { if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); } if (timeoutMilliseconds == 0) { return !task.IsCompleted; // timed out if not completed } var cts = new CancellationTokenSource(); if (await Task.WhenAny( task, Task.Delay(timeoutMilliseconds, cts.Token)) == task) { cts.Cancel(); // task completed, get rid of timer await task; // test for exceptions or task cancellation return false; // did not timeout } else { return true; // did timeout } }タイムアウトが発生した場合に作業タスクを開始して作業を取り消したい場合は、次のようにします。
public static async Task<T> CancelAfterAsync<T>( this Func<CancellationToken,Task<T>> actionAsync, int timeoutMilliseconds) { if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); } var taskCts = new CancellationTokenSource(); var timerCts = new CancellationTokenSource(); Task<T> task = actionAsync(taskCts.Token); if (await Task.WhenAny(task, Task.Delay(timeoutMilliseconds, timerCts.Token)) == task) { timerCts.Cancel(); // task completed, get rid of timer } else { taskCts.Cancel(); // timer completed, get rid of task } return await task; // test for exceptions or task cancellation }タイムアウトが発生した場合にキャンセルしたいタスクが既に作成されている場合
public static async Task<T> CancelAfterAsync<T>(this Task<T> task, int timeoutMilliseconds, CancellationTokenSource taskCts) { if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); } var timerCts = new CancellationTokenSource(); if (await Task.WhenAny(task, Task.Delay(timeoutMilliseconds, timerCts.Token)) == task) { timerCts.Cancel(); // task completed, get rid of timer } else { taskCts.Cancel(); // timer completed, get rid of task } return await task; // test for exceptions or task cancellation }
もう1つのコメントは、これらのバージョンではタイムアウトが発生しない場合はタイマーがキャンセルされるため、複数の呼び出しによってタイマーが重ならないようにすることです。
sjb
BlockingCollectionを使用してタスクをスケジュールすると、プロデューサは長時間実行される可能性があるタスクを実行でき、コンシューマはタイムアウトとキャンセルトークンが組み込まれたTryTakeメソッドを使用できます。