多线程那点事—Parallel.for

先看段代码：

for (int i = 0; i < 10; i++)
{
    Task.Factory.StartNew(()=>Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} ~ {i}"));
}

从代码上可以看出我们预期是打印1~10，但实际的打印结果是：

7 ~ 10
4 ~ 10
10 ~ 10
9 ~ 10
4 ~ 10
3 ~ 10
5 ~ 10
9 ~ 10
6 ~ 10
8 ~ 10

与预期的不一致，我们预期是打印数字1到10，但实际打印出来的是10次10。因为这几个lambda表达式中使用了同一个变量，并且这些匿名函数共享变量值。

再来看下面这段代码：

Action<int> displayNumber = n => Console.WriteLine(n);
int i = 5;
Task taskOne = Task.Factory.StartNew(() => displayNumber(i));
i = 7;
Task taskTwo = Task.Factory.StartNew(() => displayNumber(i));
Task.WaitAll(taskOne,taskTwo);

输出结果：

7
7

当闭包通过lambda表达式捕获可变变量时，lambda捕获变量的引用，而不是捕获该变量的当前值。因此，如果任务在变量的引用值更改后运行，则该值将是内存中最新的值，而不是捕获变量时的值。

为解决该问题，我们引入Parallel类来解决问题：

Parallel.For(0,10,i=>Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} ~ {i}"));

打印结果：

1 ~ 0
1 ~ 2
3 ~ 1
3 ~ 4
3 ~ 7
3 ~ 8
3 ~ 9
1 ~ 3
5 ~ 5
4 ~ 6

Parallel 类 提供对并行循环和区域的支持， 现在我们看下Parallel.for的代码：

// this needs to be in try-block because it can throw in  BuggyScheduler.MaxConcurrencyLevel
                rootTask = new ParallelForReplicatingTask(
                    parallelOptions,
                    delegate
                    {
                        //
                        // first thing we do upon enterying the task is to register  as a new "RangeWorker" with the
                        // shared RangeManager instance.
                        //
                        // If this call returns a RangeWorker struct which wraps the  state needed by this task
                        //
                        // We need to call FindNewWork32() on it to see whether  there's a chunk available.
                        //
                        // Cache some information about the current task
                        Task currentWorkerTask = Task.InternalCurrent;
                        bool bIsRootTask = (currentWorkerTask == rootTask);
                        RangeWorker currentWorker = new RangeWorker();
                        Object savedStateFromPreviousReplica =  currentWorkerTask.SavedStateFromPreviousReplica;
                        if (savedStateFromPreviousReplica is RangeWorker)
                            currentWorker =  (RangeWorker)savedStateFromPreviousReplica;
                        else
                            currentWorker = rangeManager.RegisterNewWorker();
                        // These are the local index values to be used in the  sequential loop.
                        // Their values filled in by FindNewWork32
                        int nFromInclusiveLocal;
                        int nToExclusiveLocal;
                        if (currentWorker.FindNewWork32(out nFromInclusiveLocal, out  nToExclusiveLocal) == false ||
                            sharedPStateFlags.ShouldExitLoop(nFromInclusiveLocal) ==  true)
                        {
                            return; // no need to run
                        }
                        // ETW event for ParallelFor Worker Fork
                        if (TplEtwProvider.Log.IsEnabled())
                        {
                            TplEtwProvider.Log.ParallelFork((currentWorkerTask != null  ? currentWorkerTask.m_taskScheduler.Id : TaskScheduler.Current.Id),  (currentWorkerTask != null ? currentWorkerTask.Id : 0),
                                                             forkJoinContextID);
                        }
                        TLocal localValue = default(TLocal);
                        bool bLocalValueInitialized = false; // Tracks whether  localInit ran without exceptions, so that we can skip localFinally if it wasn't
                        try
                        {
                            // Create a new state object that references the shared  "stopped" and "exceptional" flags
                            // If needed, it will contain a new instance of  thread-local state by invoking the selector.
                            ParallelLoopState32 state = null;
                            if (bodyWithState != null)
                            {
                                Contract.Assert(sharedPStateFlags != null);
                                state = new ParallelLoopState32(sharedPStateFlags);
                            }
                            else if (bodyWithLocal != null)
                            {
                                Contract.Assert(sharedPStateFlags != null);
                                state = new ParallelLoopState32(sharedPStateFlags);
                                if (localInit != null)
                                {
                                    localValue = localInit();
                                    bLocalValueInitialized = true;
                                }
                            }
                            // initialize a loop timer which will help us decide  whether we should exit early
                            LoopTimer loopTimer = new  LoopTimer(rootTask.ActiveChildCount);
                            // Now perform the loop itself.
                            do
                            {
                                if (body != null)
                                {
                                    for (int j = nFromInclusiveLocal;
                                         j < nToExclusiveLocal &&  (sharedPStateFlags.LoopStateFlags == ParallelLoopStateFlags.PLS_NONE  // fast path  check as SEL() doesn't inline
                                                                   ||  !sharedPStateFlags.ShouldExitLoop()); // the no-arg version is used since we have  no state
                                         j += 1)
                                    {
                                        body(j);
                                    }
                                }
                                else if (bodyWithState != null)
                                {
                                    for (int j = nFromInclusiveLocal;
                                        j < nToExclusiveLocal &&  (sharedPStateFlags.LoopStateFlags == ParallelLoopStateFlags.PLS_NONE  // fast path  check as SEL() doesn't inline
                                                                   ||  !sharedPStateFlags.ShouldExitLoop(j));
                                        j += 1)
                                    {
                                        state.CurrentIteration = j;
                                        bodyWithState(j, state);
                                    }
                                }
                                else
                                {
                                    for (int j = nFromInclusiveLocal;
                                        j < nToExclusiveLocal &&  (sharedPStateFlags.LoopStateFlags == ParallelLoopStateFlags.PLS_NONE  // fast path  check as SEL() doesn't inline
                                                                   ||  !sharedPStateFlags.ShouldExitLoop(j));
                                        j += 1)
                                    {
                                        state.CurrentIteration = j;
                                        localValue = bodyWithLocal(j, state,  localValue);
                                    }
                                }
                                // Cooperative multitasking hack for AppDomain  fairness.
                                // Check if allowed loop time is exceeded, if so save  current state and return. The self replicating task logic
                                // will detect this, and queue up a replacement task.  Note that we don't do this on the root task.
                                if (!bIsRootTask && loopTimer.LimitExceeded())
                                {
                                    currentWorkerTask.SavedStateForNextReplica =  (object)currentWorker;
                                    break;
                                }
                            }
                            // Exit if we can't find new work, or if the loop was  stoppped.
                            while (currentWorker.FindNewWork32(out  nFromInclusiveLocal, out nToExclusiveLocal) &&
                                    ((sharedPStateFlags.LoopStateFlags ==  ParallelLoopStateFlags.PLS_NONE) ||
                                       !sharedPStateFlags.ShouldExitLoop(nFromInclusiveLocal)));
                        }
                        catch
                        {
                            // if we catch an exception in a worker, we signal the  other workers to exit the loop, and we rethrow
                            sharedPStateFlags.SetExceptional();
                            throw;
                        }
                        finally
                        {
                            // If a cleanup function was specified, call it.  Otherwise, if the type is
                            // IDisposable, we will invoke Dispose on behalf of the  user.
                            if (localFinally != null && bLocalValueInitialized)
                            {
                                localFinally(localValue);
                            }
                            // ETW event for ParallelFor Worker Join
                            if (TplEtwProvider.Log.IsEnabled())
                            {
                                TplEtwProvider.Log.ParallelJoin((currentWorkerTask !=  null ? currentWorkerTask.m_taskScheduler.Id : TaskScheduler.Current.Id),  (currentWorkerTask != null ? currentWorkerTask.Id : 0),
                                                                 forkJoinContextID);
                            }
                        }
                    },
                    creationOptions, internalOptions);
                rootTask.RunSynchronously(parallelOptions.EffectiveTaskScheduler);  // might throw TSE
                rootTask.Wait();
                // If we made a cancellation registration, we need to clean it up  now before observing the OCE
                // Otherwise we could be caught in the middle of a callback, and  observe PLS_STOPPED, but oce = null
                if (parallelOptions.CancellationToken.CanBeCanceled)
                {
                    ctr.Dispose();
                }
                // If we got through that with no exceptions, and we were canceled,  then
                // throw our cancellation exception
                if (oce != null) throw oce;

body对于迭代范围 (的每个值调用一次委托 fromInclusive ， toExclusive) 。提供两个参数：

1、一个 Int32 值，该值表示迭代次数。

2、ParallelLoopState可用于提前中断循环的实例。ParallelLoopState对象是由编译器创建的; 它不能在用户代码中实例化。

继续来看：

Parallel.For(0, 10, (i,state) =>
            {
                if (i > 5)
                    state.Break();
                Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} ~ {i}");
            } );

输出：

1 ~ 0
1 ~ 1
1 ~ 2
1 ~ 3
1 ~ 4
1 ~ 5
1 ~ 6

在上面的方法中我们使用了 break方法。

调用 Break 方法会通知 for 操作，在当前的迭代之后，无需执行迭代。不过，如果所有迭代尚未执行，则仍必须执行当前的所有迭代。

因此，调用 Break 类似于 for c# 等语言中的传统循环内的中断操作，但它并不是完美的替代方法：例如，无法保证当前的迭代不会执行。

今天就先写道这里~