并行使用TPL中预期的双线程

我将从一个基本的解释开始，我将如何理解一些工作，然后用tldr结束这一切;如果人们只是希望达到我在这里的实际问题 . 如果我对这里的任何事情的理解是错误的，请纠正我 .

TPL代表任务并行库，它是.NET 4.0的答案，试图进一步简化线程以方便开发人员使用 . 如果你不熟悉它，（在一个非常基础的层面上）你启动一个新的Task对象并传递一个委托，然后在一个从线程池中取出的后台线程上运行（通过使用线程池而不是真正制作一个通过使用这些现有线程而不是创建和处理新线程来保存新线程，时间和资源 .

根据我的理解，C＃中的Parallel.ForEach命令将为它应该执行的每个委托生成一个新线程（可能来自一个线程池），可能的例外是自动内联一个甚至可能更多的迭代，如果编译器决定它们将足够快地发生以使其更有效 .

关于我的目标最相关的背景信息：

我正在尝试制作一个快速程序，启动一个Task与程序的其余部分同时运行 . 在这个Task中，Parallel.ForEach运行3'次迭代 . 总的来说，我们希望程序现在运行总共5个线程（最多）：主线程为1，实际任务为1，Parallel.ForEach最多为3 . 每个线程都有自己的目标要完成（虽然Parallel.ForEach都有相同的目标，其相关的itemNumber值不同，以便计算 . 当主线程完成所有目标时，它使用Task.Wait（）等待在完成任务，等待Parallel.ForEach完成 . 然后使用和验证值 .

tldr;实际问题：

当运行上述想法时，Parallel.ForEach似乎正在初始化两倍于SynchronizationContexts（一个TPL对象本质上是另一个线程），正如我所期望的那样并运行所有这些，但是只等待它们的预期数量 . 因为Parallel.ForEach（） . Wait（）命令在预期的线程数量运行时完成，所以Task也会完成，因为它认为一切都已完成 . 然后主程序选择任务已完成，并且当它验证当前没有更多后台线程在运行时，有时剩余的Parrallel.ForEach（）尚未完成，因此抛出错误 .

已验证线程数量与我在每次SynchronizationContext的后调用（Async方法踢球者）上打印到调试窗口时所说的相匹配 . 每个线程也由主线程对象引用，否则计划在完成任务时将其处理掉，但由于未完成线程的引用仍然是由于未完全预期创建的，因此处理不能正确进行 .

Thread testThread = Thread.CurrentThread;
Task backgroundTask = taskFactory.StartNew(() =>
{
    Thread rootTaskThread = Thread.CurrentThread;
    Assert.AreNotEqual(testThread, rootTaskThread, "First task should not inline");
    Thread.Sleep(TimeSpan.FromSeconds(2));

    Parallel.ForEach(new[] { 1, 2, 3, 4 },
       new ParallelOptions { TaskScheduler = taskFactory.Scheduler }, (int item) => {
        Thread.Sleep(TimeSpan.FromSeconds(1));
     });
});

在上面的示例中，主线程，backgroundTask任务和8个Parallel.ForEach线程最终存在，其中最后9个在SynchronizationContexts上创建 .

在我的自定义的SynchronizationContext中重写的唯一方法是post，如下所示：

public override void Post(SendOrPostCallback d, object state){
    Request requestOrNull = Request.ExistsForCurrentThread() ? Request.GetForCurrentThread() as Request : null;
    Request.IAsyncContextData requestData = null;

    if (requestOrNull != null){
       requestData = requestOrNull.CaptureDataForNewThreadAndIncrementReferenceCount();
    }

    Debug.WriteLine("Task started - request data " + (requestData == null ? "DOES NOT EXIST" : "EXISTS"));

    base.Post((object internalState) => {
        // Capture the spawned thread state and restore the originating thread state
        try{
            if (requestData != null){
                Request.AttachToAsynchronousContext(requestData);
            }
            d(state);
        }
        finally{
            // Restore original spawned thread state
            if (requestData != null){
            // Disposes the request if this is the last reference to it
                Request.DetachFromAsynchronousContext(requestData);
            }
        Debug.WriteLine("Task completed - request data " + (requestData == null ? "DOES NOT EXIST" : "EXISTS"));
        }
    }, state);
 }

我相信TaskScheduler只做了它所需的基本内容：

private readonly RequestSynchronizationContext context;
private readonly ConcurrentQueue<Task> tasks = new ConcurrentQueue<Task>();

public RequestTaskScheduler(RequestSynchronizationContext synchronizationContext)
{
    this.context = synchronizationContext;
}

protected override void QueueTask(Task task){
    this.tasks.Enqueue(task);
    this.context.Post((object state) => {
        Task nextTask;
        if (this.tasks.TryDequeue(out nextTask)) 
            this.TryExecuteTask(nextTask);
    }, null);
}

protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued){
    if (SynchronizationContext.Current == this.context)
        return this.TryExecuteTask(task);
    else
        return false;
}

protected override IEnumerable<Task> GetScheduledTasks(){
    return this.tasks.ToArray();
}

TaskFactory：

public RequestTaskFactory(RequestTaskScheduler taskScheduler)
    : base(taskScheduler)
{ }

有关为何可能发生这种情况的任何想法？