Question

我们假设我有一个名为Scheduler的班级，其中包含Dictionary <UserId, Task>，该任务会不断循环并更新内部词典，并为该用户{{ 1}}来自数据库的信息，即我希望实时更新信息。

我希望在<UserId, Schedule>类Scheduler上有一个方法来检查该用户是否有任务，如果没有，它会创建任务等待直到完成，然后检索该用户的GetScheduleForUser（延迟加载它）。

我的问题是，在任务的第一次迭代之后，我将有一个可用的时间表，我可以只检索时间表......没问题，但是对于第一次迭代，我需要等到任务完成时在检索计划之前至少一次。

我可以启动任务并创建一个while循环，直到第一次循环完成时设置了某个标志，但在我看来，有一种更好的方法而且它只是“仅”对第一次迭代很有用。之后，计划将始终可用，我不会需要该功能。

有没有人有一个干净的方法来完成这个？

Answer 1

我能想到的最佳解决方案是使用TaskCompletionSource，Eser在评论中提到了这一点。这是一个粗略的代码示例，其中包含许多控制台输出，以便更轻松地遵循它所做的事情。我还在调度程序calss和IDisposable字典中添加了CancellationTokenSource，以便在您完成调度程序后，它可以停止所有任务。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
    // Helper property to simplify console output
    public static string TimeString { get { return DateTime.Now.ToString("mm:ss.fff"); } }

    public static void Main(string[] args)
    {
        using (var scheduler = new Scheduler())
        {
            var userID = "1";

            Console.WriteLine(TimeString + " Main: Getting schedule for first time...");
            var sched1 = scheduler.GetScheduleForUser(userID);
            Console.WriteLine(TimeString + " Main: Got schedule: " + sched1);

            Console.WriteLine(TimeString + " Main: Waiting 2 seconds...");
            System.Threading.Thread.Sleep(2000);

            Console.WriteLine(TimeString + " Main: Getting schedule for second time...");
            var sched2 = scheduler.GetScheduleForUser(userID);
            Console.WriteLine(TimeString + " Main: Got schedule: " + sched2);
        }

        Console.WriteLine();
        Console.WriteLine("Press any key to end . . .");
        Console.ReadKey();
    }
}

public class Scheduler : IDisposable
{
    // Helper property to simplify console output
    public static string TimeString { get { return DateTime.Now.ToString("mm:ss.fff"); } }

    private Dictionary<string, Task> TasksDictionary { get; set; }
    private Dictionary<string, TaskCompletionSource<bool>> TaskCompletionSourcesDictionary { get; set; }
    private Dictionary<string, CancellationTokenSource> CancellationTokenSourcesDictionary { get; set; }
    private Dictionary<string, string> SchedulesDictionary { get; set; }

    public Scheduler()
    {
        TasksDictionary = new Dictionary<string, Task>();
        TaskCompletionSourcesDictionary = new Dictionary<string, TaskCompletionSource<bool>>();
        CancellationTokenSourcesDictionary = new Dictionary<string, CancellationTokenSource>();
        SchedulesDictionary = new Dictionary<string, string>();
    }

    public void Dispose()
    {
        if (TasksDictionary != null)
        {
            if (CancellationTokenSourcesDictionary != null)
            {
                foreach (var tokenSource in CancellationTokenSourcesDictionary.Values)
                    tokenSource.Cancel();

                Task.WaitAll(TasksDictionary.Values.ToArray(), 10000);

                CancellationTokenSourcesDictionary = null;
            }

            TasksDictionary = null;
        }

        CancellationTokenSourcesDictionary = null;
        SchedulesDictionary = null;
    }

    public string GetScheduleForUser(string userID)
    {
        // There's already a schedule, so get it
        if (SchedulesDictionary.ContainsKey(userID))
        {
            Console.WriteLine(TimeString + "     GetSchedule: Already had schedule for user " + userID);
            return SchedulesDictionary[userID];
        }

        // If there's no task yet, start one
        if (!TasksDictionary.ContainsKey(userID))
        {
            Console.WriteLine(TimeString + "     GetSchedule: Starting task for user " + userID);
            var tokenSource = new CancellationTokenSource();
            var token = tokenSource.Token;
            TaskCompletionSourcesDictionary.Add(userID, new TaskCompletionSource<bool>());
            var task = (new TaskFactory()).StartNew(() => GenerateSchedule(userID, token, TaskCompletionSourcesDictionary[userID]), token);
            TasksDictionary.Add(userID, task);
            CancellationTokenSourcesDictionary.Add(userID, tokenSource);
            Console.WriteLine(TimeString + "     GetSchedule: Started task for user " + userID);
        }

        // If there's a task running, wait for it
        Console.WriteLine(TimeString + "     GetSchedule: Waiting for first run to complete for user " + userID);
        var temp = TaskCompletionSourcesDictionary[userID].Task.Result;
        Console.WriteLine(TimeString + "     GetSchedule: First run complete for user " + userID);

        return SchedulesDictionary.ContainsKey(userID) ? SchedulesDictionary[userID] : "null";
    }

    private void GenerateSchedule(string userID, CancellationToken token, TaskCompletionSource<bool> tcs)
    {
        Console.WriteLine(TimeString + "         Task: Starting task for userID " + userID);

        bool firstRun = true;
        while (!token.IsCancellationRequested)
        {
            // Simulate work while building schedule
            if (token.WaitHandle.WaitOne(1000))
                break;

            // Update schedule
            SchedulesDictionary[userID] = "Schedule set at " + DateTime.Now.ToShortTimeString();
            Console.WriteLine(TimeString + "         Task: Updated schedule for userID " + userID);

            // If this was the first run, set the result for the TaskCompletionSource
            if (firstRun)
            {
                tcs.SetResult(true);
                firstRun = false;
            }
        }

        Console.WriteLine(TimeString + "         Task: Ended task for userID " + userID);
    }
}

以下是展示行动的小提琴：.NET Fiddle

如何确保任务中的循环至少运行一次

1 个答案: