共享资源访问的优化同步

Question

对于我的控制台应用程序，我实现了一个简单的文件记录器。记录器使用StringBuilder 来保持追加日志条目并将LogText 数据写入最后的LogFile。这导致只有一个文件 I/O 操作。应用程序的执行必须非常快，因此，我已经实现了Parallel.ForEach 以及async-await，并尽可能减少了 I/O 操作。

问题是Logger 不是线程安全的。使用lock 或Monitor 在Parallel.ForEach 循环内同步共享资源logger 会降低性能。有没有什么对执行速度影响不大的共享资源同步的最佳方式？

我愿意接受其他方法或建议。

Logger.cs

public class Logger
{
    private readonly string LogFile;
    private readonly StringBuilder LogText;

    public Logger(string logFile)
    {
        LogFile = logFile;
        LogText = new StringBuilder();
    }

    public void Write(string message)
    {
        LogText.AppendLine(message);
    }
    
    public void WriteToFile()
    {
        File.AppendAllText(LogFile, LogText.ToString());
    }
}

程序.cs

public class Program
{
    public static void Main(string[] args)
    {
        string logFile = args[0];
        string workingDirectory = args[1];
        Logger logger = new Logger(logFile);
        logger.Write($"INFO | Execution Started");

        try
        {
            List<string> files = Directory.EnumerateFiles(workingDirectory, "*", SearchOption.AllDirectories).ToList();
            Parallel.ForEach(files, async file =>
            {
                List<string> results = await PerformCPUBoundComputationAsync();
                foreach(string result in results)
                {
                    logger.Write($"INFO | Item: {result}");
                }
                string response = await MakePostRequestAsync(results);
                logger.Write($"INFO | Response: {response}");
            });
        }
        catch (Exception ex)
        {
            logger.Write($"ERROR | {ex.Message}");
        }
        finally
        {
            logger.Write($"INFO | Execution Ended");
            logger.WriteToFile();
        }
    }
}

Answer 1

这不是使用您的 Logger 类，我只是想向您展示另一种方法

首先我们不将Parallel.ForEach 用于IO 绑定工作，它不适合，而且我们绝对不给它一个async lambda（这是一个未观察到的async void），它表示Parallel.ForEach 将在所有任务完成之前完成。

至于你的问题：

1. 要解决已完成任务的问题，让我们使用WhenAll
2. 为了解决线程安全问题，让我们为每个任务创建一个单独的字符串生成器。这有点分配，但它是无锁的。
3. 让我们把所有的日志写在最后

async 和 await 模式会在完成 IO-bound 工作时将线程返回到线程池。任务调度程序会将这些线程用于 CPU 密集型工作。

var tasks = Directory
   .EnumerateFiles(workingDirectory, "*", SearchOption.AllDirectories)
   .Select(async x =>
   {
      var sb = new StringBuilder();
      List<string> results = // do cpu bound work, no need for fake async, 
      // thats to say no need to offload to another thread. 
      foreach (string result in results)
         sb.AppendLine($"INFO | Item: {result}");
      string response = await MakePostRequestAsync(results);
      sb.AppendLine($"INFO | Response: {response}");
      return sb;
   });

// await all your work to finish
var logs = await Task.WhenAll(tasks);

// write the results to the file
using var sw = new StreamWriter("FileName");
sw.WriteLine($"INFO | Execution Started");

foreach (var log in logs)
   sw.WriteLine(log);

sw.WriteLine($"INFO | Execution Ended");

注意：这可能会导致分配和内存压力，具体取决于日志的大小。在这种情况下，您可能需要返回到同步原语，并承担锁定的代价。

另一种有效的方法是使用诸如 Tpl Dataflow 管道之类的东西，进行计算，发布帖子，然后将结果批处理以进行写入，这可能会减少分配并具有处理同步和异步的优势工作量。

Processing (parallel)
       v
Posting (parallel)
       v
Batched Log Writes (Singular)