任务并行库中的任务如何影响ActivityID？

Question

在使用任务并行库之前，我经常使用 CorrelationManager.ActivityId 来跟踪多线程的跟踪/错误报告。

ActivityId 存储在线程本地存储中，因此每个线程都有自己的副本。这个想法是，当您启动线程（活动）时，您分配一个新的 ActivityId。 ActivityId 将与任何其他跟踪信息一起写入日志，从而可以挑选出单个“活动”的跟踪信息。这对于 WCF 来说非常有用，因为 ActivityId 可以转移到服务组件。

下面是我正在讨论的一个示例：

static void Main(string[] args)
{
    ThreadPool.QueueUserWorkItem(new WaitCallback((o) =>
    {
        DoWork();
    }));
}

static void DoWork()
{
    try
    {
        Trace.CorrelationManager.ActivityId = Guid.NewGuid();
        //The functions below contain tracing which logs the ActivityID.
        CallFunction1();
        CallFunction2();
        CallFunction3();
    }
    catch (Exception ex)
    {
        Trace.Write(Trace.CorrelationManager.ActivityId + " " + ex.ToString());
    }
}

现在，对于 TPL，我的理解是多个任务共享线程。这是否意味着 ActivityId 很容易在任务中（由另一个任务）重新初始化？是否有新的机制来处理活动跟踪？

Answer 1

我进行了一些实验，结果证明我的问题中的假设是不正确的 - 使用 TPL 创建的多个任务不会同时在同一线程上运行。

ThreadLocalStorage 可以安全地与 .NET 4.0 中的 TPL 一起使用，因为一个线程一次只能由一个任务使用。

任务可以同时共享线程的假设是基于我听说的一次采访< strong>c# 5.0 on DotNetRocks （抱歉，我不记得那是哪个节目了） - 所以我的问题可能（或可能不会）很快变得相关。

我的实验启动了多个任务，并记录了运行了多少个任务、运行了多长时间以及消耗了多少个线程。如果有人想重复的话，代码如下。

class Program
{
    static void Main(string[] args)
    {
        int totalThreads = 100;
        TaskCreationOptions taskCreationOpt = TaskCreationOptions.None;
        Task task = null;
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        Task[] allTasks = new Task[totalThreads];
        for (int i = 0; i < totalThreads; i++)
        {
            task = Task.Factory.StartNew(() =>
           {
               DoLongRunningWork();
           }, taskCreationOpt);

            allTasks[i] = task;
        }

        Task.WaitAll(allTasks);
        stopwatch.Stop();

        Console.WriteLine(String.Format("Completed {0} tasks in {1} milliseconds", totalThreads, stopwatch.ElapsedMilliseconds));
        Console.WriteLine(String.Format("Used {0} threads", threadIds.Count));
        Console.ReadKey();
    }


    private static List<int> threadIds = new List<int>();
    private static object locker = new object();
    private static void DoLongRunningWork()
    {
        lock (locker)
        {
            //Keep a record of the managed thread used.
            if (!threadIds.Contains(Thread.CurrentThread.ManagedThreadId))
                threadIds.Add(Thread.CurrentThread.ManagedThreadId);
        }
        Guid g1 = Guid.NewGuid();
        Trace.CorrelationManager.ActivityId = g1;
        Thread.Sleep(3000);
        Guid g2 = Trace.CorrelationManager.ActivityId;
        Debug.Assert(g1.Equals(g2));
    }
}

输出（当然这取决于机器）是：

Completed 100 tasks in 23097 milliseconds
Used 23 threads

将 taskCreationOpt 更改为 TaskCreationOptions.LongRunning 给出了不同的结果：

Completed 100 tasks in 3458 milliseconds 
Used 100 threads

Answer 2

请原谅我将其发布为答案，因为它并不是真正回答您的问题，但是，它与您的问题相关，因为它涉及 CorrelationManager 行为和线程/任务/等。我一直在考虑使用 CorrelationManager 的 LogicalOperationStack（和 StartLogicalOperation/StopLogicalOperation 方法）在多线程场景中提供额外的上下文。

我采用了您的示例并对其进行了稍微修改，以添加使用 Parallel.For 并行执行工作的能力。另外，我使用 StartLogicalOperation/StopLogicalOperation 来括起（内部）DoLongRunningWork。从概念上讲，DoLongRunningWork 每次执行时都会执行类似的操作：

DoLongRunningWork
  StartLogicalOperation
  Thread.Sleep(3000)
  StopLogicalOperation

我发现，如果我将这些逻辑操作添加到代码中（或多或少按原样），所有逻辑操作都会保持同步（堆栈上的操作数始终是预期的，并且堆栈上操作的值始终符合预期）。

在我自己的一些测试中，我发现情况并非总是如此。逻辑操作堆栈正在“损坏”。我能想到的最好的解释是，当“子”线程退出时，将 CallContext 信息“合并”回“父”线程上下文会导致“旧”子线程上下文信息（逻辑操作）变为“由另一个兄弟子线程继承”。

该问题也可能与以下事实有关：Parallel.For 显然使用主线程（至少在示例代码中，如所写）作为“工作线程”之一（或在并行域中应调用它们的任何线程）。每当执行 DoLongRunningWork 时，都会启动一个新的逻辑操作（在开始时）并停止（在结束时）（即，推入 LogicalOperationStack 并从其中弹出）。如果主线程已经有一个有效的逻辑操作，并且 DoLongRunningWork 在主线程上执行，则将启动一个新的逻辑操作，因此主线程的 LogicalOperationStack 现在有两个操作。 DoLongRunningWork 的任何后续执行（只要 DoLongRunningWork 的这一“迭代”在主线程上执行）将（显然）继承主线程的 LogicalOperationStack（现在它有两个操作，而不仅仅是一个预期操作）。

我花了很长时间才弄清楚为什么 LogicalOperationStack 的行为在我的示例中与我的示例的修改版本中不同。最后我发现在我的代码中我已经将整个程序括在逻辑运算中，而在我的测试程序的修改版本中我没有。这意味着在我的测试程序中，每次执行我的“工作”（类似于DoLongRunningWork）时，已经有一个有效的逻辑操作。在我对测试程序的修改版本中，我没有将整个程序括在逻辑运算中。

因此，当我修改您的测试程序以将整个程序括在逻辑运算中并且如果我使用 Parallel.For 时，我遇到了完全相同的问题。

使用上面的概念模型，这将成功运行：

Parallel.For
  DoLongRunningWork
    StartLogicalOperation
    Sleep(3000)
    StopLogicalOperation

虽然这最终会由于明显不同步的 LogicalOperationStack 而断言：

StartLogicalOperation
Parallel.For
  DoLongRunningWork
    StartLogicalOperation
    Sleep(3000)
    StopLogicalOperation
StopLogicalOperation

这是我的示例程序。它与您的类似，因为它有一个操作 ActivityId 和 LogicalOperationStack 的 DoLongRunningWork 方法。我对 DoLongRunningWork 的踢法也有两种风格。一种使用任务，一种使用 Parallel.For。还可以执行每种风格，使得整个并行操作包含在逻辑操作中或不包含在逻辑操作中。因此，共有4种并行操作的执行方式。要尝试每一种方法，只需取消注释所需的“Use...”方法，重新编译并运行即可。 UseTasks、UseTasks(true) 和 UseParallelFor 应该全部运行完成。 UseParallelFor(true) 将在某个时刻断言，因为 LogicalOperationStack 没有预期的条目数。

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

namespace CorrelationManagerParallelTest
{
  class Program 
  {     
    static void Main(string[] args)     
    { 
      //UseParallelFor(true) will assert because LogicalOperationStack will not have expected
      //number of entries, all others will run to completion.

      UseTasks(); //Equivalent to original test program with only the parallelized
                      //operation bracketed in logical operation.
      ////UseTasks(true); //Bracket entire UseTasks method in logical operation
      ////UseParallelFor();  //Equivalent to original test program, but use Parallel.For
                             //rather than Tasks.  Bracket only the parallelized
                             //operation in logical operation.
      ////UseParallelFor(true); //Bracket entire UseParallelFor method in logical operation
    }       

    private static List<int> threadIds = new List<int>();     
    private static object locker = new object();     

    private static int mainThreadId = Thread.CurrentThread.ManagedThreadId;

    private static int mainThreadUsedInDelegate = 0;

    // baseCount is the expected number of entries in the LogicalOperationStack
    // at the time that DoLongRunningWork starts.  If the entire operation is bracketed
    // externally by Start/StopLogicalOperation, then baseCount will be 1.  Otherwise,
    // it will be 0.
    private static void DoLongRunningWork(int baseCount)     
    {
      lock (locker)
      {
        //Keep a record of the managed thread used.             
        if (!threadIds.Contains(Thread.CurrentThread.ManagedThreadId))
          threadIds.Add(Thread.CurrentThread.ManagedThreadId);

        if (Thread.CurrentThread.ManagedThreadId == mainThreadId)
        {
          mainThreadUsedInDelegate++;
        }
      }         

      Guid lo1 = Guid.NewGuid();
      Trace.CorrelationManager.StartLogicalOperation(lo1);

      Guid g1 = Guid.NewGuid();         
      Trace.CorrelationManager.ActivityId = g1;

      Thread.Sleep(3000);         

      Guid g2 = Trace.CorrelationManager.ActivityId;
      Debug.Assert(g1.Equals(g2));

      //This assert, LogicalOperation.Count, will eventually fail if there is a logical operation
      //in effect when the Parallel.For operation was started.
      Debug.Assert(Trace.CorrelationManager.LogicalOperationStack.Count == baseCount + 1, string.Format("MainThread = {0}, Thread = {1}, Count = {2}, ExpectedCount = {3}", mainThreadId, Thread.CurrentThread.ManagedThreadId, Trace.CorrelationManager.LogicalOperationStack.Count, baseCount + 1));
      Debug.Assert(Trace.CorrelationManager.LogicalOperationStack.Peek().Equals(lo1), string.Format("MainThread = {0}, Thread = {1}, Count = {2}, ExpectedCount = {3}", mainThreadId, Thread.CurrentThread.ManagedThreadId, Trace.CorrelationManager.LogicalOperationStack.Peek(), lo1));

      Trace.CorrelationManager.StopLogicalOperation();
    } 

    private static void UseTasks(bool encloseInLogicalOperation = false)
    {
      int totalThreads = 100;
      TaskCreationOptions taskCreationOpt = TaskCreationOptions.None;
      Task task = null;
      Stopwatch stopwatch = new Stopwatch();
      stopwatch.Start();

      if (encloseInLogicalOperation)
      {
        Trace.CorrelationManager.StartLogicalOperation();
      }

      Task[] allTasks = new Task[totalThreads];
      for (int i = 0; i < totalThreads; i++)
      {
        task = Task.Factory.StartNew(() =>
        {
          DoLongRunningWork(encloseInLogicalOperation ? 1 : 0);
        }, taskCreationOpt);
        allTasks[i] = task;
      }
      Task.WaitAll(allTasks);

      if (encloseInLogicalOperation)
      {
        Trace.CorrelationManager.StopLogicalOperation();
      }

      stopwatch.Stop();
      Console.WriteLine(String.Format("Completed {0} tasks in {1} milliseconds", totalThreads, stopwatch.ElapsedMilliseconds));
      Console.WriteLine(String.Format("Used {0} threads", threadIds.Count));
      Console.WriteLine(String.Format("Main thread used in delegate {0} times", mainThreadUsedInDelegate));

      Console.ReadKey();
    }

    private static void UseParallelFor(bool encloseInLogicalOperation = false)
    {
      int totalThreads = 100;
      Stopwatch stopwatch = new Stopwatch();
      stopwatch.Start();

      if (encloseInLogicalOperation)
      {
        Trace.CorrelationManager.StartLogicalOperation();
      }

      Parallel.For(0, totalThreads, i =>
      {
        DoLongRunningWork(encloseInLogicalOperation ? 1 : 0);
      });

      if (encloseInLogicalOperation)
      {
        Trace.CorrelationManager.StopLogicalOperation();
      }

      stopwatch.Stop();
      Console.WriteLine(String.Format("Completed {0} tasks in {1} milliseconds", totalThreads, stopwatch.ElapsedMilliseconds));
      Console.WriteLine(String.Format("Used {0} threads", threadIds.Count));
      Console.WriteLine(String.Format("Main thread used in delegate {0} times", mainThreadUsedInDelegate));

      Console.ReadKey();
    }

  } 
}

LogicalOperationStack 是否可以与 Parallel.For （和/或其他线程/任务构造）一起使用或如何使用它的整个问题可能值得它自己的问题。也许我会发布一个问题。同时，我想知道您对此是否有任何想法（或者，我想知道您是否考虑过使用 LogicalOperationStack，因为 ActivityId 似乎是安全的）。

[编辑]

请参阅我对此的回答 有关使用 LogicalOperationStack 和/或 CallContext.LogicalSetData 以及各种 Thread/ThreadPool/Task/Parallel 构造中的一些的更多信息，请参阅问题。

另请参阅我关于 LogicalOperationStack 和 Parallel 扩展的问题：
CorrelationManager.LogicalOperationStack 是否与 Parallel.For、任务、线程等兼容< /a>

最后，另请参阅我在 Microsoft 并行扩展论坛上的问题：
http://social. msdn.microsoft.com/Forums/en-US/parallelextensions/thread/7c5c3051-133b-4814-9db0-fc0039b4f9d9

在我的测试中，使用 Parallel.For 或 Parallel 时，Trace.CorrelationManager.LogicalOperationStack 可能会损坏.如果您在主线程中启动逻辑操作，然后在委托中启动/停止逻辑操作，则调用。在我的测试中（请参阅上面的两个链接之一），当执行 DoLongRunningWork 时，LogicalOperationStack 应该始终有 2 个条目（如果我在使用各种技术启动 DoLongRunningWork 之前在主线程中启动逻辑操作）。因此，我所说的“损坏”是指 LogicalOperationStack 最终将拥有超过 2 个条目。

据我所知，这可能是因为 Parallel.For 和 Parallel.Invoke 使用主线程作为“工作”线程之一来执行 DoLongRunningWork 操作。

使用存储在 CallContext.LogicalSetData 中的堆栈来模拟 LogicalOperationStack 的行为（类似于通过 CallContext.SetData 存储的 log4net 的 LogicalThreadContext.Stacks）会产生更糟糕的结果。如果我使用这样的堆栈来维护上下文，那么在几乎所有主线程中有“逻辑操作”并且每次迭代中有逻辑操作的情况下，它都会被损坏（即没有预期的条目数） /DoLongRunningWork 委托的执行。