NLog 的线程安全性如何？

Question

好吧，

我等了好几天才决定发布这个问题，因为我不知道如何陈述这一点，结果变成了一篇很长的详细帖子。不过，我认为此时向社区寻求帮助是有意义的。

基本上，我尝试使用 NLog 为数百个线程配置记录器。我认为这会非常简单，但几十秒后我得到了这个异常： “InvalidOperationException：集合已修改；枚举操作可能无法执行”

以下是代码。

//Launches threads that initiate loggers
class ThreadManager
{
    //(...)
    for (int i = 0; i<500; i++)
    {
        myWorker wk = new myWorker();
        wk.RunWorkerAsync();
    }

    internal class myWorker : : BackgroundWorker
    {             
       protected override void OnDoWork(DoWorkEventArgs e)
       {              
           // "Logging" is Not static - Just to eliminate this possibility 
           // as an error culprit
           Logging L = new Logging(); 
           //myRandomID is a random 12 characters sequence
           //iLog Method is detailed below
          Logger log = L.iLog(myRandomID);
          base.OnDoWork(e);
       }
    }
}

public class Logging
{   
        //ALL THis METHOD IS VERY BASIC NLOG SETTING - JUST FOR THE RECORD
        public Logger iLog(string loggerID)
        {
        LoggingConfiguration config;
        Logger logger;
        FileTarget FileTarget;            
        LoggingRule Rule; 

        FileTarget = new FileTarget();
        FileTarget.DeleteOldFileOnStartup = false;
        FileTarget.FileName =  "X:\\" + loggerID + ".log";

        AsyncTargetWrapper asyncWrapper = new AsyncTargetWrapper();
        asyncWrapper.QueueLimit = 5000;
        asyncWrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Discard;
        asyncWrapper.WrappedTarget = FileTarget;

        //config = new LoggingConfiguration(); //Tried to Fool NLog by this trick - bad idea as the LogManager need to keep track of all config content (which seems to cause my problem;               
        config = LogManager.Configuration;                
        config.AddTarget("File", asyncWrapper);                
        Rule = new LoggingRule(loggerID, LogLevel.Info, FileTarget);

        lock (LogManager.Configuration.LoggingRules)
            config.LoggingRules.Add(Rule);                

        LogManager.Configuration = config;
        logger = LogManager.GetLogger(loggerID);

        return logger;
    }
}   

所以我完成了我的工作，而不只是在这里发布我的问题并享受家庭质量的时光，我花了周末的时间来挖掘这个问题（幸运的男孩！） 我下载了 NLOG 2.0 的最新稳定版本并将其包含在我的项目中。我能够追踪到它爆炸的确切位置：

在 LogFactory.cs 中：

    internal void GetTargetsByLevelForLogger(string name, IList<LoggingRule> rules, TargetWithFilterChain[] targetsByLevel, TargetWithFilterChain[] lastTargetsByLevel)
    {
        //lock (rules)//<--Adding this does not fix it
            foreach (LoggingRule rule in rules)//<-- BLOWS HERE
            {
            }
     }

在 LoggingConfiguration.cs 中：

internal void FlushAllTargets(AsyncContinuation asyncContinuation)
    {            
        var uniqueTargets = new List<Target>();
        //lock (LoggingRules)//<--Adding this does not fix it
        foreach (var rule in this.LoggingRules)//<-- BLOWS HERE
        {
        }
     }

我认为的问题
因此，根据我的理解，发生的情况是 LogManager 会混淆，因为从不同线程调用 config.LoggingRules.Add(Rule)，而 GetTargetsByLevelForLogger 和 < em>FlushAllTargets 正在被调用。 我尝试拧紧 foreach 并将其替换为 for 循环，但记录器变得流氓（跳过许多日志文件创建）

SOoooo FINALLY
到处都写着 NLOG 是线程安全的，但我浏览了一些帖子，进一步深入研究并声称这取决于使用场景。我的情况呢？ 我必须创建数千个记录器（不是同时创建，但仍然以非常高的速度）。

我发现的解决方法是在同一个主线程中创建所有记录器；这确实很不方便，因为我在应用程序启动时创建了所有应用程序记录器（类似于记录器池）。 尽管它工作起来很甜蜜，但这并不是一个可以接受的设计。

所以你们都知道了。 请帮助一名程序员再次见到他的家人。

Answer 1

我并没有真正回答您的问题，但我确实有一些观察和一些问题：

根据您的代码，您似乎想为每个线程创建一个记录器，并且希望将该记录器记录到名为的文件中对于一些传入的 id 值。因此，id 为“abc”的记录器将记录到“x:\abc.log”，“def”将记录到“x:\def.log”，依此类推。我怀疑您可以通过 NLog 配置而不是通过编程来完成此操作。我不知道它是否会更好，或者 NLog 是否会遇到与您相同的问题。

我的第一印象是您正在做很多工作：为每个线程创建一个文件目标，为每个线程创建一个新规则，获取一个新的记录器实例等，您可能不需要做这些工作来完成您想要的事情来完成。

我知道 NLog 允许至少基于一些 NLog LayoutRenderer 动态命名输出文件。例如，我知道这是可行的：

fileName="${level}.log"

并且会给你这样的文件名：

Trace.log
Debug.log
Info.log
Warn.log
Error.log
Fatal.log

因此，例如，似乎你可以使用这样的模式来基于线程 id 创建输出文件：

fileName="${threadid}.log"

如果你最终有线程 101 和 102，那么您将有两个日志文件：101.log 和 102.log。

在你的例子中，你想根据你自己的 id 来命名文件。您可以将 id 存储在 MappedDiagnosticContext （这是一个字典，允许您存储线程本地名称-值对），然后在您的模式中引用它。

您的文件名模式看起来像这样：

fileName="${mdc:myid}.log"

因此，在您的代码中您可以这样做：

         public class ThreadManager
         {
           //Get one logger per type.
           private static readonly Logger logger = LogManager.GetCurrentClassLogger();

           protected override void OnDoWork(DoWorkEventArgs e)
           {
             // Set the desired id into the thread context
             NLog.MappedDiagnosticsContext.Set("myid", myRandomID);

             logger.Info("Hello from thread {0}, myid {1}", Thread.CurrentThread.ManagedThreadId, myRandomID);
             base.OnDoWork(e);  

             //Clear out the random id when the thread work is finished.
             NLog.MappedDiagnosticsContext.Remove("myid");
           }
         }

像这样的东西应该允许您的 ThreadManager 类有一个名为“ThreadManager”的记录器。每次记录消息时，它都会在 Info 调用中记录格式化字符串。如果记录器配置为记录到文件目标（在配置文件中制定一条规则，将“*.ThreadManager”发送到文件目标，其文件名布局如下所示：

fileName="${basedir}/${mdc:myid}.log"

记录消息时，NLog 将确定什么文件名应该基于 fileName 布局的值（即，它在日志时应用格式化标记）。如果文件存在，则将消息写入其中。如果文件尚不存在，则创建该文件。 如果每个线程都有一个随机ID

，如“aaaaaaaaaaa”、“aaaaaaaaaaab”、“aaaaaaaaaaac”，那么您应该获得如下日志文件：

aaaaaaaaaaaa.log
aaaaaaaaaaab.log
aaaaaaaaaaac.log

等等

如果您可以这样做，那么 。你的生活应该更简单，因为你不需要 NLog 的所有编程配置（创建规则和文件目标）并且你可以让 NLog 担心创建输出文件名，

我不确定这是否有效 。或者，即使确实如此，你可能确实需要从更大的角度来看你正在做的事情。测试它是否有效应该很容易（即您可以根据 MappedDiagnosticContext 中的值命名输出文件）。如果它适用于该情况，那么您可以在创建数千个线程的情况下尝试它。

更新：

这是一些示例代码：

使用此程序：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using NLog;
using System.Threading;
using System.Threading.Tasks;

namespace NLogMultiFileTest
{
  class Program
  {
    public static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {

      int totalThreads = 50;
      TaskCreationOptions tco = TaskCreationOptions.None;
      Task task = null;

      logger.Info("Enter Main");

      Task[] allTasks = new Task[totalThreads];
      for (int i = 0; i < totalThreads; i++)
      {
        int ii = i;
        task = Task.Factory.StartNew(() =>
        {
          MDC.Set("id", "_" + ii.ToString() + "_");
          logger.Info("Enter delegate.  i = {0}", ii);
          logger.Info("Hello! from delegate.  i = {0}", ii);
          logger.Info("Exit delegate.  i = {0}", ii);
          MDC.Remove("id");
        });

        allTasks[i] = task;
      }

      logger.Info("Wait on tasks");

      Task.WaitAll(allTasks);

      logger.Info("Tasks finished");

      logger.Info("Exit Main");
    }
  }
}

以及此 NLog.config 文件：

<?xml version="1.0" encoding="utf-8" ?>
<!-- 
  This file needs to be put in the application directory. Make sure to set 
  'Copy to Output Directory' option in Visual Studio.
  -->
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <targets>
        <target name="file" xsi:type="File" layout="${longdate} | ${processid} | ${threadid} | ${logger} | ${level} | id=${mdc:id} | ${message}" fileName="${basedir}/log_${mdc:item=id}.txt" />
    </targets>

    <rules>
        <logger name="*" minlevel="Debug" writeTo="file" />
    </rules>
</nlog>

我能够为委托的每次执行获取一个日志文件。日志文件以 MDC (MappedDiagnosticContext) 中存储的“id”命名。

因此，当我运行示例程序时，我得到了 50 个日志文件，每个日志文件都有三行“Enter...”、“Hello...”、“Exit...”。每个文件都命名为 log__X_.txt，其中 X 是捕获的计数器 (ii) 的值，因此我有 log_0.txt、log_1.txt、log_1.txt 等、log_49.txt。每个日志文件仅包含与委托的一次执行相关的日志消息。

这与您想要做的类似吗？我的示例程序使用任务而不是线程，因为我之前已经编写过它。我认为该技术应该足够容易地适应你正在做的事情。

您也可以使用相同的 NLog.config 文件以这种方式（为委托的每次执行获取一个新的记录器）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using NLog;
using System.Threading;
using System.Threading.Tasks;

namespace NLogMultiFileTest
{
  class Program
  {
    public static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {

      int totalThreads = 50;
      TaskCreationOptions tco = TaskCreationOptions.None;
      Task task = null;

      logger.Info("Enter Main");

      Task[] allTasks = new Task[totalThreads];
      for (int i = 0; i < totalThreads; i++)
      {
        int ii = i;
        task = Task.Factory.StartNew(() =>
        {
          Logger innerLogger = LogManager.GetLogger(ii.ToString());
          MDC.Set("id", "_" + ii.ToString() + "_");
          innerLogger.Info("Enter delegate.  i = {0}", ii);
          innerLogger.Info("Hello! from delegate.  i = {0}", ii);
          innerLogger.Info("Exit delegate.  i = {0}", ii);
          MDC.Remove("id");
        });

        allTasks[i] = task;
      }

      logger.Info("Wait on tasks");

      Task.WaitAll(allTasks);

      logger.Info("Tasks finished");

      logger.Info("Exit Main");
    }
  }
}

Answer 2

这是一个较老的问题，但作为 NLog 的当前所有者，我有以下见解：

• 创建记录器是线程安全的
• 编写日志消息是线程安全
• 的 上下文类和渲染器的使用（GDC、MDC 等）是线程安全的
• 添加运行时的新目标+规则是线程安全的（当使用LoggingConfiguration.AddRule + ReconfigExistingLoggers时）
• 执行LoggingConfiguration的重新加载将导致活动记录器中的LogEvents被删除，直到重新加载完成。
• 在运行时更改现有规则和目标的值不是线程安全的！

您应该避免在运行时更改现有项目的值。相反，应该使用 上下文渲染器 ($ {事件属性}、${GDC}、${MDLC} 等）

Answer 3

我不了解 NLog，但从上面的内容和 API 文档（http://nlog-project.org/help/）可以看出，只有一种静态配置。因此，如果您想仅在创建记录器（每个记录器来自不同的线程）时使用此方法向配置添加规则，则您正在编辑相同的配置对象。据我在 NLog 文档中看到的，无法为每个记录器使用单独的配置，因此这就是您需要所有规则的原因。

添加规则的最佳方法是在启动异步工作线程之前添加规则，但我假设这不是您想要的。

也可以只为所有工人使用一台记录器。但我假设您需要将每个工作人员放在一个单独的文件中。

如果每个线程都创建自己的记录器并将自己的规则添加到配置中，则必须在其周围加锁。请注意，即使您同步了代码，在您更改规则时仍然有可能其他一些代码正在枚举规则。正如您所展示的，NLog 不会对这些代码位进行锁定。所以我认为任何线程安全声明仅适用于实际的日志写入方法。

我不确定你现有的锁是做什么的，但我不认为它没有达到你的预期。因此，更改

...
lock (LogManager.Configuration.LoggingRules)
config.LoggingRules.Add(Rule);                

LogManager.Configuration = config;
logger = LogManager.GetLogger(loggerID);

return logger;

为

...
lock(privateConfigLock){
    LogManager.Configuration.LoggingRules.Add(Rule);                

    logger = LogManager.GetLogger(loggerID);
}
return logger;

“请注意，仅锁定您“拥有”的对象（即您的类私有的对象）被认为是最佳实践。这可以防止其他代码中的某些类（不符合最佳实践）锁定同一代码，从而可能导致死锁。因此，我们应该将 privateConfigLock 定义为您的类的私有。我们还应该将其设为静态，以便每个线程都能看到相同的对象引用，如下所示：

public class Logging{
    // object used to synchronize the addition of config rules and logger creation
    private static readonly object privateConfigLock = new object();
...

Answer 4

我认为您可能没有正确使用lock。您正在锁定传递到您的方法中的对象，因此我认为这意味着不同的线程可能会锁定不同的对象。

大多数人只是将其添加到他们的类中：

private static readonly object Lock = new object();

然后锁定它并保证它始终是同一个对象。

我不确定这会解决你的问题，但你现在所做的事情对我来说很奇怪。
其他人可能不同意。

Answer 5

通过枚举集合的副本，您可以解决这个问题。我对 NLog 源代码进行了以下更改，似乎解决了问题：

internal void GetTargetsByLevelForLogger(string name, IList<LoggingRule> rules, TargetWithFilterChain[] targetsByLevel, TargetWithFilterChain[] lastTargetsByLevel)
{
   foreach (LoggingRule rule in rules.ToList<LoggingRule>())
   {
   ... 

Answer 6

根据 他们的 wiki 上的文档，它们是线程安全的：

因为记录器是线程安全的，所以您只需创建一次记录器并将其存储在静态变量中

根据您收到的错误，您很可能正在执行异常所指示的操作：在 foreach 循环时修改代码中某处的集合正在迭代。由于您的列表是通过引用传递的，因此不难想象在您迭代规则集合时另一个线程将在哪里修改规则集合。您有两个选择：

1. 预先创建所有规则，然后批量添加它们（我认为这是您想要的）。
2. 将您的列表转换为某个只读集合 (rules.AsReadOnly())，但会错过您生成的线程创建新规则时发生的任何更新。