C#应用并行运行代码块及定时/重复调用Task的实现问询

嘿，针对你这个C#应用并行运行多任务的需求，我给你梳理一套实用的实现方案，涵盖单次并行、定时和重复任务的场景，咱们一步步来：

首先说你提到的Task.Run(() => MyFirstTask())的方式——如果你的任务是IO密集型（比如调用异步API、数据库操作），其实不需要额外用Task.Run，直接调用异步方法就能返回Task，然后用Task.WhenAll来并行等待所有任务完成，这样更高效，因为async/await本来就是为IO密集型场景优化的：

// 并行执行多个单次异步任务
public async Task RunAllOneTimeTasksAsync()
{
    // 把所有单次任务放到集合里
    var oneTimeTasks = new List<Task>
    {
        MyFirstTask(),
        MySecondTask(),
        // 这里可以继续添加更多单次任务...
    };

    // 等待所有任务完成，它们会并行执行
    await Task.WhenAll(oneTimeTasks);
}

如果你的任务里有同步阻塞的CPU密集型代码（比如复杂计算、Thread.Sleep），那用Task.Run把它放到线程池线程是合理的，避免阻塞主线程：

var cpuBoundTasks = new List<Task>
{
    Task.Run(() => MyCpuIntensiveTask()),
    Task.Run(() => AnotherCpuTask()),
};
await Task.WhenAll(cpuBoundTasks);

对于需要重复执行的任务，推荐用循环+Task.Delay的方式，同时配合CancellationToken实现优雅取消，这样可以控制任务的启停，还能处理异常避免循环崩溃：

// 通用重复任务执行方法：上一次任务完成后，等待指定间隔再执行
private async Task RunRepeatingTaskAsync(Func<Task> taskToRun, TimeSpan repeatInterval, CancellationToken cancellationToken)
{
    while (!cancellationToken.IsCancellationRequested)
    {
        try
        {
            // 执行目标任务
            await taskToRun();
        }
        catch (Exception ex)
        {
            // 一定要捕获异常，不然单个任务崩溃会导致整个重复循环终止
            Console.WriteLine($"重复任务执行出错: {ex.Message}");
            // 这里可以根据需求添加告警、日志等逻辑
        }

        // 等待下一次执行间隔，同时响应取消信号
        await Task.Delay(repeatInterval, cancellationToken);
    }
}

调用示例（比如每5分钟跑一次MyFirstTask）：

var cts = new CancellationTokenSource();
await RunRepeatingTaskAsync(MyFirstTask, TimeSpan.FromMinutes(5), cts.Token);

如果是需要在固定时间点运行的任务（比如每天上午10点），可以计算到下一次运行时间的间隔，再用Task.Delay等待：

// 通用定时任务执行方法：每天固定时间点运行
private async Task RunScheduledTaskAsync(Func<Task> taskToRun, TimeSpan dailyTargetTime, CancellationToken cancellationToken)
{
    while (!cancellationToken.IsCancellationRequested)
    {
        var now = DateTime.Now;
        // 计算今天的目标运行时间
        var nextRunTime = now.Date.Add(dailyTargetTime);
        
        // 如果今天的时间已经过了，就安排到明天
        if (nextRunTime <= now)
        {
            nextRunTime = nextRunTime.AddDays(1);
        }

        // 计算需要等待的时长
        var delayUntilNextRun = nextRunTime - now;
        try
        {
            // 等待到目标时间，同时响应取消信号
            await Task.Delay(delayUntilNextRun, cancellationToken);
            
            // 确认任务没被取消，再执行
            if (!cancellationToken.IsCancellationRequested)
            {
                await taskToRun();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"定时任务执行出错: {ex.Message}");
        }
    }
}

调用示例（每天10点跑MySecondTask）：

var cts = new CancellationTokenSource();
await RunScheduledTaskAsync(MySecondTask, new TimeSpan(10, 0, 0), cts.Token);

实际场景中你可能同时有单次、重复、定时任务，这时需要统一管理它们的生命周期，用CancellationTokenSource来统一取消所有任务：

private CancellationTokenSource _taskCts;

// 启动所有任务
public async Task StartAllTasksAsync()
{
    _taskCts = new CancellationTokenSource();
    var allTasks = new List<Task>
    {
        // 启动单次并行任务
        RunAllOneTimeTasksAsync(),
        
        // 启动重复任务
        RunRepeatingTaskAsync(MyFirstTask, TimeSpan.FromMinutes(5), _taskCts.Token),
        
        // 启动定时任务
        RunScheduledTaskAsync(MySecondTask, new TimeSpan(10, 0, 0), _taskCts.Token),
        
        // 添加更多任务...
    };

    // 等待所有任务完成（或者被取消）
    await Task.WhenAll(allTasks);
}

// 停止所有任务（比如应用关闭时调用）
public void StopAllTasks()
{
    _taskCts?.Cancel();
    _taskCts?.Dispose();
}

• 异常处理：每个任务内部或者循环里一定要加try-catch，避免单个任务的崩溃导致整个任务链终止
• 取消令牌：必须使用CancellationToken来优雅停止任务，尤其是长时间运行的重复/定时任务，不能强制终止线程
• 资源清理：你的任务里的cleanup代码，最好用try-finally包裹，确保无论任务是否抛出异常，清理逻辑都能执行
• Task.Run的适用场景：只有当任务包含同步阻塞代码时才需要用Task.Run，纯IO密集型的异步任务直接调用即可

内容的提问来源于stack exchange，提问作者user687554