Sinkron menunggu Tugas <T> selesai dengan batas waktu

Saya ingin menunggu Tugas <T> diselesaikan dengan beberapa aturan khusus: Jika belum selesai setelah X milidetik, saya ingin menampilkan pesan kepada pengguna. Dan jika belum selesai setelah Y milidetik, saya ingin secara otomatis meminta pembatalan .

Saya bisa menggunakan Task.ContinueWith untuk secara asinkron menunggu tugas selesai (yaitu menjadwalkan tindakan yang akan dieksekusi ketika tugas selesai), tetapi itu tidak memungkinkan untuk menentukan batas waktu. Saya bisa menggunakan Task.Wait untuk secara sinkron menunggu tugas selesai dengan batas waktu, tetapi itu memblokir utas saya. Bagaimana saya bisa tidak sinkron menunggu tugas selesai dengan batas waktu?

Bagaimana dengan ini:

int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
    // task completed within timeout
} else { 
    // timeout logic
}

Dan di sini ada posting blog yang bagus "Crafting a Task.TimeoutAfter Method" (dari tim MS Parallel Library) dengan info lebih lanjut tentang hal semacam ini .

Tambahan : atas permintaan komentar pada jawaban saya, berikut ini adalah solusi diperluas yang mencakup penanganan pembatalan. Perhatikan bahwa meneruskan pembatalan ke tugas dan timer berarti bahwa ada beberapa cara pembatalan dapat dialami dalam kode Anda, dan Anda harus yakin untuk menguji dan yakin Anda menangani semuanya dengan benar. Jangan biarkan berbagai kombinasi kebetulan dan berharap komputer Anda melakukan hal yang benar saat runtime.

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
}

Berikut adalah versi metode ekstensi yang menyertakan pembatalan batas waktu ketika tugas asli selesai seperti yang disarankan oleh Andrew Arnott dalam komentar untuk jawabannya .

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.");
        }
    }
}

Anda dapat menggunakan Task.WaitAnyuntuk menunggu yang pertama dari banyak tugas.

Anda dapat membuat dua tugas tambahan (yang selesai setelah batas waktu yang ditentukan) dan kemudian gunakan WaitAnyuntuk menunggu mana yang lebih dulu selesai. Jika tugas yang diselesaikan pertama adalah tugas "pekerjaan" Anda, maka Anda selesai. Jika tugas yang diselesaikan pertama adalah tugas batas waktu, maka Anda dapat bereaksi terhadap batas waktu tersebut (mis. Permintaan pembatalan).

Bagaimana dengan sesuatu yang seperti ini?

    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();
    }

Anda dapat menggunakan opsi Task.Wait tanpa memblokir utas menggunakan Tugas lain.

Berikut adalah contoh yang berfungsi sepenuhnya berdasarkan jawaban yang dipilih teratas, yaitu:

int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
    // task completed within timeout
} else { 
    // timeout logic
}

Keuntungan utama dari implementasi dalam jawaban ini adalah bahwa obat generik telah ditambahkan, sehingga fungsi (atau tugas) dapat mengembalikan nilai. Ini berarti bahwa setiap fungsi yang ada dapat dibungkus dengan fungsi batas waktu, misalnya:

Sebelum:

int x = MyFunc();

Setelah:

// Throws a TimeoutException if MyFunc takes more than 1 second
int x = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));

Kode ini membutuhkan .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();
            }
        }
    }
}

Peringatan

Setelah memberikan jawaban ini, biasanya bukan praktik yang baik untuk memiliki pengecualian yang dimasukkan dalam kode Anda selama operasi normal, kecuali Anda benar-benar harus:

• Setiap kali pengecualian dilemparkan, ini merupakan operasi yang sangat berat,
• Pengecualian dapat memperlambat kode Anda dengan faktor 100 atau lebih jika pengecualian dalam loop ketat.

Gunakan hanya kode ini jika Anda benar-benar tidak dapat mengubah fungsi yang Anda panggil sehingga waktu habis setelah spesifik TimeSpan.

Jawaban ini benar-benar hanya berlaku ketika berhadapan dengan perpustakaan perpustakaan pihak ke-3 yang Anda tidak bisa menolak untuk memasukkan parameter batas waktu.

Cara menulis kode yang kuat

Jika Anda ingin menulis kode yang kuat, aturan umumnya adalah ini:

Setiap operasi yang berpotensi memblokir tanpa batas waktu, harus memiliki batas waktu.

Jika Anda tidak mematuhi aturan ini, kode Anda pada akhirnya akan mengenai operasi yang gagal karena suatu alasan, maka itu akan diblokir tanpa batas waktu, dan aplikasi Anda baru saja digantung secara permanen.

Jika ada batas waktu yang wajar setelah beberapa waktu, maka aplikasi Anda akan hang selama beberapa waktu yang ekstrem (misalnya 30 detik) maka ia akan menampilkan kesalahan dan melanjutkan dengan cara riang, atau coba lagi.

Menggunakan pustaka AsyncEx Stephen Cleary yang sangat baik , Anda dapat melakukan:

TimeSpan timeout = TimeSpan.FromSeconds(10);

using (var cts = new CancellationTokenSource(timeout))
{
    await myTask.WaitAsync(cts.Token);
}

TaskCanceledException akan dilemparkan jika terjadi timeout.

Ini adalah versi yang sedikit lebih baik dari jawaban sebelumnya.

• Selain jawaban Lawrence , itu membatalkan tugas asli ketika batas waktu terjadi.
• Sebagai tambahan untuk varian jawaban sjb 2 dan 3 , Anda dapat menyediakan CancellationTokenuntuk tugas asli, dan ketika batas waktu terjadi, Anda mendapatkan TimeoutExceptionalih-alih OperationCanceledException.

async Task<TResult> CancelAfterAsync<TResult>(
    Func<CancellationToken, Task<TResult>> startTask,
    TimeSpan timeout, CancellationToken cancellationToken)
{
    using (var timeoutCancellation = new CancellationTokenSource())
    using (var combinedCancellation = CancellationTokenSource
        .CreateLinkedTokenSource(cancellationToken, timeoutCancellation.Token))
    {
        var originalTask = startTask(combinedCancellation.Token);
        var delayTask = Task.Delay(timeout, timeoutCancellation.Token);
        var completedTask = await Task.WhenAny(originalTask, delayTask);
        // Cancel timeout to stop either task:
        // - Either the original task completed, so we need to cancel the delay task.
        // - Or the timeout expired, so we need to cancel the original task.
        // Canceling will not affect a task, that is already completed.
        timeoutCancellation.Cancel();
        if (completedTask == originalTask)
        {
            // original task completed
            return await originalTask;
        }
        else
        {
            // timeout
            throw new TimeoutException();
        }
    }
}

Pemakaian

InnerCallAsyncmungkin butuh waktu lama untuk selesai. CallAsyncmembungkusnya dengan batas waktu.

async Task<int> CallAsync(CancellationToken cancellationToken)
{
    var timeout = TimeSpan.FromMinutes(1);
    int result = await CancelAfterAsync(ct => InnerCallAsync(ct), timeout,
        cancellationToken);
    return result;
}

async Task<int> InnerCallAsync(CancellationToken cancellationToken)
{
    return 42;
}

Gunakan Timer untuk menangani pesan dan pembatalan otomatis. Saat Tugas selesai, hubungi Buang penghitung waktu agar mereka tidak akan pernah menyala. Berikut ini sebuah contoh; ubah taskDelay menjadi 500, 1500, atau 2500 untuk melihat berbagai kasus:

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);
                }
            }
        }
    }
}

Juga, CTP Async menyediakan metode TaskEx.Delay yang akan membungkus pengatur waktu dalam tugas untuk Anda. Ini dapat memberi Anda lebih banyak kontrol untuk melakukan hal-hal seperti mengatur TaskScheduler untuk kelanjutan ketika Timer menyala.

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;
}

Cara lain untuk memecahkan masalah ini adalah menggunakan Ekstensi Reaktif:

public static Task TimeoutAfter(this Task task, TimeSpan timeout, IScheduler scheduler)
{
        return task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

Uji di atas menggunakan kode di bawah ini dalam unit test Anda, itu berfungsi untuk saya

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);

Anda mungkin memerlukan namespace berikut:

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;

Versi generik jawaban @ Kevan di atas, menggunakan Ekstensi Reaktif.

public static Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout, IScheduler scheduler)
{
    return task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

Dengan Penjadwal opsional:

public static Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout, Scheduler scheduler = null)
{
    return scheduler is null 
       ? task.ToObservable().Timeout(timeout).ToTask() 
       : task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

BTW: Ketika Timeout terjadi, eksepsi timeout akan dilempar

Jika Anda menggunakan BlockingCollection untuk menjadwalkan tugas, produsen dapat menjalankan tugas yang berpotensi berjalan lama dan konsumen dapat menggunakan metode TryTake yang memiliki batas waktu dan token pembatalan bawaan.

Saya merasakan Task.Delay()tugas danCancellationTokenSource jawaban lain sedikit banyak untuk kasus penggunaan saya dalam loop jaringan yang ketat.

Dan meskipun begitu Joe Hoag's Crafting a Task.TimeoutSetelah Metode di blog MSDN menginspirasi, saya sedikit lelah menggunakanTimeoutException untuk kontrol aliran untuk alasan yang sama seperti di atas, karena timeout diharapkan lebih sering daripada tidak.

Jadi saya pergi dengan ini, yang juga menangani optimasi yang disebutkan di blog:

public static async Task<bool> BeforeTimeout(this Task task, int millisecondsTimeout)
{
    if (task.IsCompleted) return true;
    if (millisecondsTimeout == 0) return false;

    if (millisecondsTimeout == Timeout.Infinite)
    {
        await Task.WhenAll(task);
        return true;
    }

    var tcs = new TaskCompletionSource<object>();

    using (var timer = new Timer(state => ((TaskCompletionSource<object>)state).TrySetCanceled(), tcs,
        millisecondsTimeout, Timeout.Infinite))
    {
        return await Task.WhenAny(task, tcs.Task) == task;
    }
}

Contoh use case adalah sebagai berikut:

var receivingTask = conn.ReceiveAsync(ct);

while (!await receivingTask.BeforeTimeout(keepAliveMilliseconds))
{
    // Send keep-alive
}

// Read and do something with data
var data = await receivingTask;

Beberapa varian jawaban Andrew Arnott:

1. Jika Anda ingin menunggu tugas yang ada dan mencari tahu apakah tugasnya selesai atau waktunya habis, tetapi tidak ingin membatalkannya jika batas waktu terjadi:

   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
       }
   }

2. Jika Anda ingin memulai tugas kerja dan membatalkan pekerjaan jika batas waktu terjadi:

   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
   }

3. Jika Anda memiliki tugas yang sudah dibuat yang ingin Anda batalkan jika terjadi timeout:

   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
   }

Komentar lain, versi ini akan membatalkan timer jika batas waktu tidak terjadi, sehingga beberapa panggilan tidak akan menyebabkan timer menumpuk.

sjb

Saya menggabungkan ide-ide dari beberapa jawaban lain di sini dan jawaban ini di utas lain menjadi metode ekstensi gaya Try. Ini memiliki manfaat jika Anda menginginkan metode ekstensi, namun menghindari pengecualian pada batas waktu.

public static async Task<bool> TryWithTimeoutAfter<TResult>(this Task<TResult> task,
    TimeSpan timeout, Action<TResult> successor)
{

    using var timeoutCancellationTokenSource = new CancellationTokenSource();
    var completedTask = await Task.WhenAny(task, Task.Delay(timeout, timeoutCancellationTokenSource.Token))
                                  .ConfigureAwait(continueOnCapturedContext: false);

    if (completedTask == task)
    {
        timeoutCancellationTokenSource.Cancel();

        // propagate exception rather than AggregateException, if calling task.Result.
        var result = await task.ConfigureAwait(continueOnCapturedContext: false);
        successor(result);
        return true;
    }
    else return false;        
}     

async Task Example(Task<string> task)
{
    string result = null;
    if (await task.TryWithTimeoutAfter(TimeSpan.FromSeconds(1), r => result = r))
    {
        Console.WriteLine(result);
    }
}    

Jelas tidak melakukan ini, tetapi itu adalah pilihan jika ... Saya tidak bisa memikirkan alasan yang sah.

((CancellationTokenSource)cancellationToken.GetType().GetField("m_source",
    System.Reflection.BindingFlags.NonPublic |
    System.Reflection.BindingFlags.Instance
).GetValue(cancellationToken)).Cancel();