[英]Creating a Task with a heartbeat
I'd like to run a Task that has a " heartbeat " that keeps running at a specific time interval until the task completes. 我想运行一个具有“ 心跳 ”的任务 ,该任务以特定的时间间隔继续运行,直到任务完成。
I'm thinking an extension method like this would work well: 我在想这样的扩展方法效果很好:
public static async Task WithHeartbeat(this Task primaryTask, TimeSpan heartbeatInterval, Action<CancellationToken> heartbeatAction, CancellationToken cancellationToken)
For example: 例如:
public class Program {
public static void Main() {
var cancelTokenSource = new CancellationTokenSource();
var cancelToken = cancelTokenSource.Token;
var longRunningTask = Task.Factory.StartNew(SomeLongRunningTask, cancelToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);
var withHeartbeatTask = longRunningTask.WithHeartbeat(TimeSpan.FromSeconds(1), PerformHeartbeat, cancelToken);
withHeartbeatTask.Wait();
Console.WriteLine("Long running task completed!");
Console.ReadLine()
}
private static void SomeLongRunningTask() {
Console.WriteLine("Starting long task");
Thread.Sleep(TimeSpan.FromSeconds(9.5));
}
private static int _heartbeatCount = 0;
private static void PerformHeartbeat(CancellationToken cancellationToken) {
Console.WriteLine("Heartbeat {0}", ++_heartbeatCount);
}
}
This program should output: 该程序应输出:
Starting long task
Heartbeat 1
Heartbeat 2
Heartbeat 3
Heartbeat 4
Heartbeat 5
Heartbeat 6
Heartbeat 7
Heartbeat 8
Heartbeat 9
Long running task completed!
Note that it should not (under normal circumstances) output "Heartbeat 10" since the heartbeat starts after the initial timeout (ie 1 second). 请注意,它不应(在正常情况下)输出“Heartbeat 10”,因为心跳在初始超时(即1秒)后开始。 Similarly, if the task takes less time than the heartbeat interval, the heartbeat should not occur at all. 同样,如果任务花费的时间少于心跳间隔,则根本不应发生心跳。
What is a good way to implement this? 实现这个的好方法是什么?
Background information: I have a service that's listening to an Azure Service Bus queue. 背景信息:我有一个服务正在侦听Azure Service Bus队列。 I'd like to not Complete the message (which would permanently remove it from the queue) until I finish processing it, which could take longer than the maximum message LockDuration of 5 minutes. 我想不完成消息(将永久删除它从队列中),直到我完成处理它,这可能需要比最长消息LockDuration 5分钟更长的时间。 Thus, I need to use this heartbeat approach to call RenewLockAsync before the lock duration expires so that the message doesn't timeout while lengthy processing is occurring. 因此,我需要使用此心跳方法在锁定持续时间到期之前调用RenewLockAsync ,以便在发生冗长处理时消息不会超时。
Here's my attempt: 这是我的尝试:
public static class TaskExtensions {
/// <summary>
/// Issues the <paramref name="heartbeatAction"/> once every <paramref name="heartbeatInterval"/> while <paramref name="primaryTask"/> is running.
/// </summary>
public static async Task WithHeartbeat(this Task primaryTask, TimeSpan heartbeatInterval, Action<CancellationToken> heartbeatAction, CancellationToken cancellationToken) {
if (cancellationToken.IsCancellationRequested) {
return;
}
var stopHeartbeatSource = new CancellationTokenSource();
cancellationToken.Register(stopHeartbeatSource.Cancel);
await Task.WhenAny(primaryTask, PerformHeartbeats(heartbeatInterval, heartbeatAction, stopHeartbeatSource.Token));
stopHeartbeatSource.Cancel();
}
private static async Task PerformHeartbeats(TimeSpan interval, Action<CancellationToken> heartbeatAction, CancellationToken cancellationToken) {
while (!cancellationToken.IsCancellationRequested) {
try {
await Task.Delay(interval, cancellationToken);
if (!cancellationToken.IsCancellationRequested) {
heartbeatAction(cancellationToken);
}
}
catch (TaskCanceledException tce) {
if (tce.CancellationToken == cancellationToken) {
// Totally expected
break;
}
throw;
}
}
}
}
or with a slight tweak, you can even make the heartbeat async as in: 或者稍微调整一下,你甚至可以像以下一样使心跳异步:
/// <summary>
/// Awaits a fresh Task created by the <paramref name="heartbeatTaskFactory"/> once every <paramref name="heartbeatInterval"/> while <paramref name="primaryTask"/> is running.
/// </summary>
public static async Task WithHeartbeat(this Task primaryTask, TimeSpan heartbeatInterval, Func<CancellationToken, Task> heartbeatTaskFactory, CancellationToken cancellationToken) {
if (cancellationToken.IsCancellationRequested) {
return;
}
var stopHeartbeatSource = new CancellationTokenSource();
cancellationToken.Register(stopHeartbeatSource.Cancel);
await Task.WhenAll(primaryTask, PerformHeartbeats(heartbeatInterval, heartbeatTaskFactory, stopHeartbeatSource.Token));
if (!stopHeartbeatSource.IsCancellationRequested) {
stopHeartbeatSource.Cancel();
}
}
public static Task WithHeartbeat(this Task primaryTask, TimeSpan heartbeatInterval, Func<CancellationToken, Task> heartbeatTaskFactory) {
return WithHeartbeat(primaryTask, heartbeatInterval, heartbeatTaskFactory, CancellationToken.None);
}
private static async Task PerformHeartbeats(TimeSpan interval, Func<CancellationToken, Task> heartbeatTaskFactory, CancellationToken cancellationToken) {
while (!cancellationToken.IsCancellationRequested) {
try {
await Task.Delay(interval, cancellationToken);
if (!cancellationToken.IsCancellationRequested) {
await heartbeatTaskFactory(cancellationToken);
}
}
catch (TaskCanceledException tce) {
if (tce.CancellationToken == cancellationToken) {
// Totally expected
break;
}
throw;
}
}
}
which would allow you to change the sample code to something like this: 这将允许您将示例代码更改为以下内容:
private static async Task PerformHeartbeat(CancellationToken cancellationToken) {
Console.WriteLine("Starting heartbeat {0}", ++_heartbeatCount);
await Task.Delay(1000, cancellationToken);
Console.WriteLine("Finishing heartbeat {0}", _heartbeatCount);
}
The PerformHeartbeat could be replaced with an async call like RenewLockAsync so that you wouldn't have to waste thread time using a blocking call like RenewLock that the Action approach would require. PerformHeartbeat可以替换为RenewLockAsync之类的异步调用,这样您就不必使用Action方法需要的阻塞调用(如RenewLock)来浪费线程时间。
I'm answering my own question per SO guidelines , but I'm also open to more elegant approaches to this problem. 我根据SO指南回答了我自己的问题 ,但我也对这个问题采取更优雅的方法。
Here's my approach 这是我的方法
using System;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Start Main");
StartTest().Wait();
Console.ReadLine();
Console.WriteLine("Complete Main");
}
static async Task StartTest()
{
var cts = new CancellationTokenSource();
// ***Use ToArray to execute the query and start the download tasks.
Task<bool>[] tasks = new Task<bool>[2];
tasks[0] = LongRunningTask("", 20, cts.Token);
tasks[1] = Heartbeat("", 1, cts.Token);
// ***Call WhenAny and then await the result. The task that finishes
// first is assigned to firstFinishedTask.
Task<bool> firstFinishedTask = await Task.WhenAny(tasks);
Console.WriteLine("first task Finished.");
// ***Cancel the rest of the downloads. You just want the first one.
cts.Cancel();
// ***Await the first completed task and display the results.
// Run the program several times to demonstrate that different
// websites can finish first.
var isCompleted = await firstFinishedTask;
Console.WriteLine("isCompleted: {0}", isCompleted);
}
private static async Task<bool> LongRunningTask(string id, int sleep, CancellationToken ct)
{
Console.WriteLine("Starting long task");
await Task.Delay(TimeSpan.FromSeconds(sleep));
Console.WriteLine("Completed long task");
return true;
}
private static async Task<bool> Heartbeat(string id, int sleep, CancellationToken ct)
{
while(!ct.IsCancellationRequested)
{
await Task.Delay(TimeSpan.FromSeconds(sleep));
Console.WriteLine("Heartbeat Task Sleep: {0} Second", sleep);
}
return true;
}
}
} }
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.