主页 / 问题 / 868637
Accepted
dmitriy
Asked:2020-08-14 23:17:44 +0000 UTC2020-08-14 23:17:44 +0000 UTC

多线程。最好的方法

  • 772

任务是做一个通过SNMP监控硬件的程序（别问为什么，我自己都惊呆了）我打算用c#和SNMP lex库。可以监控很多铁片，一百片，甚至更多。每一块铁都有一堆参数用于监控。

想这样做。每个参数的监控在一个无限循环中的单独任务中启动，并且每 5 秒轮询一次参数。

看起来很可怕，因为 20 个参数的 100 块铁，一共 2000 个无限循环的任务。

建议如何最好地解决问题？

c#

2 个回答

  1. Best Answer

    假设您将异步请求信息。
    例如，所以

    static Random r = new Random();
public Task<int> GetDeviceParameter(int deviceId, int parameterId)
{
  return Task.Delay(1000).ContinueWith(t=>r.Next());
}

    我假设请求需要 1 秒。现在我们将为特定设备请求 20 个参数

    public Task<int[]> ReadDeviceParameters(int decviceId)
{
  var tasks = new Task<int>[20];

  for(var i=0; i<20; i++)
  {
    tasks[i] = GetDeviceParameter(decviceId, i);
  }

  return Task.WhenAll(tasks);
}

    一切似乎都很简单。请求 100 台设备

    public Task<int[][]> ReadParameters()
{
  var tasks = new Task<int[]>[100];

  for (var i = 0; i < 100; i++)
  {
    tasks[i] = ReadDeviceParameters(i);
  }

  return Task.WhenAll(tasks);
}

    现在，如何组织一个循环？我们可能应该有一个循环的取消令牌并对其计时，以便循环每 5 秒运行一次，但在处理先前的请求之后。

    public async Task ReadParametersLoop(CancellationToken token)
{
  while(!token.IsCancellationRequested) 
  { 
    var start = DateTime.UtcNow;
    Console.WriteLine($"Starting read at {start:mm:ss}");

    await ReadParameters(); 

    var end = DateTime.UtcNow;
    var diff = end - start;
    var delay = (int)Math.Min(5000, 5000 - diff.TotalMilliseconds);
    Console.WriteLine($"Reading ens at {end:mm:ss}, took {diff}, delay for {delay}");

    if (delay > 0)
      await Task.Delay(delay);
  }
}

    我在控制台中运行了 15 秒

    var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(15));
await ReadParametersLoop(cts.Token);

    我得到结果 

    Starting read at 29:56
Reading ens at 29:57, took 00:00:01.0061006, delay for 3993
Starting read at 30:01
Reading ens at 30:02, took 00:00:01.0161016, delay for 3983
Starting read at 30:06
Reading ens at 30:07, took 00:00:01.0161016, delay for 3983

    因此，如果请求在不到 5 秒（总共）内完成，那么它们会持续每 5 秒被请求一次。

    • 2

  2. 您可以利用System.Reactive反应式扩展

    一个关于如何使用参数监视IObservable 而不是Dictionary参数的小示例，您可以创建一个单独的类。

    class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine($"Start: {DateTime.Now}");
        var parameters = Enumerable.Range(0, 100).Select(x => $"Parameter {x}").ToArray();
        var devices = Enumerable.Range(0, 20).Select(x => $"Device {x}").ToArray();

        foreach (var device in devices)
        {
            var monitor = Observable.FromAsync(() => GetParametersAsync(parameters))
            .Delay(TimeSpan.FromSeconds(5))
            .Repeat();

            monitor.Subscribe(x => HandleParameters(device, x));
        }

        Console.ReadLine();
    }

    /// <summary>
    /// Пример обработки параметров
    /// </summary>
    private static void HandleParameters(string device, Dictionary<string, string> parameters)
    {

        foreach (var parameter in parameters)
        {
            Console.WriteLine($"{device} {parameter.Key}: {parameter.Value}");
        }
        Console.WriteLine();
    }

    private static async Task<Dictionary<string, string>> GetParametersAsync(string[] parameterIds)
    {
        var parameters = parameterIds.Select(parameterId => new { Id = parameterId, Task = GetParameterAsync(parameterId) }).ToList();
        var tasks = parameters.Select(x => x.Task).ToArray();
        await Task.WhenAll(tasks);
        var results = new Dictionary<string, string>();
        foreach (var parameter in parameters)
        {
            results.Add(parameter.Id, parameter.Task.Result);
        }
        return results;
    }

    /// <summary>
    /// Эмуляция получения данных
    /// </summary>
    public static async Task<string> GetParameterAsync(string parameterId) 
    {
        await Task.Delay(3000);
        return DateTime.Now.ToString();
    }
}
    • 2

相关问题