Parallel.For 你可能忽視的一個非常實用的過載方法

　 說起Parallel.For大家都不會陌生，很簡單，不就是一個提供並行功能的for迴圈嗎？ 或許大家平時使用到的差不多就是其中最簡單的那個過載方法，而真實情況

下Parallel.For裡面有14個過載，而其中那些比較複雜的過載方法，或許還有同學還不知道怎麼用呢~~~ 剛好我最近我有應用場景了，給大家介紹介紹，廢話不多說，

先給大家看一下這個並行方法的過載一覽表吧。。。

 

一：遇到的場景

     我遇到的場景是這樣的，專案中有這樣一個功能，這個功能需要根據多個維度對一組customerIDList進行篩選，最後求得多個維度所篩選出客戶的並集，我舉個

例子：現有8個維度：

1. 交易行為

2.營銷活動

3.地區

4.新老客戶

5.營銷渠道

6.客戶屬性

7.客戶分組

8.商品

每個維度都能篩選出一批customerid出來，然後對8組customerid求並集，這種場景很明顯要提升效能的話，你必須要做並行處理，當然能夠實現的方式有很多種，

比如我定義8個task<T>，然後使用WaitAll等待一下，最後再累計每個Result的結果就可以了，程式碼如下：

class Program
{
    static void Main(string[] args)
    {
        List<string> rankList = Enum.GetNames(typeof(FilterType)).ToList();

        Task<HashSet<int>>[] tasks = new Task<HashSet<int>>[rankList.Count];

        var hashCustomerIDList = new HashSet<int>();  //求customerid的並集

        for (int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = Task.Factory.StartNew<HashSet<int>>((obj) =>
            {
                //業務方法，耗損效能中。。。
                var smallCustomerIDHash = GetXXXMethod(rankList[(int)obj]);

                return smallCustomerIDHash;
            }, i);
        }

        Task.WaitAll(tasks);

        foreach (var task in tasks)
        {
            foreach (var item in task.Result)
            {
                hashCustomerIDList.Add(item);
            }
        }
    }

    static HashSet<int> GetXXXMethod(string rank)
    {
        return new HashSet<int>();
    }

    public enum FilterType
    {
        交易行為 = 1,
        營銷活動 = 2,
        地區 = 4,
        新老客戶 = 8,
        營銷渠道 = 16,
        客戶屬性 = 32,
        客戶分組 = 64,
        商品 = 128
    }
}

      上面的程式碼的邏輯還是很簡單的，我使用的是Task<T>的模式，當然你也可以用void形式的Task，然後在裡面lock程式碼的時候對hashCustomerIDList進行

插入，實現起來也是非常簡單的，我就不演示了，那下面的問題來了，有沒有更爽更直接的方式，看人家看上去更有檔次一點的方法，而且還要達到這種效果呢？

 

二：Parallel.For複雜過載

 回到文章開頭的話題，首先我們仔細分析一下下面這個複雜的過載方法。

 //
        // 摘要:
        //     執行具有執行緒本地資料的 for（在 Visual Basic 中為 For）迴圈，其中可能會並行執行迭代，而且可以監視和操作迴圈的狀態。
        //
        // 引數:
        //   fromInclusive:
        //     開始索引（含）。
        //
        //   toExclusive:
        //     結束索引（不含）。
        //
        //   localInit:
        //     用於返回每個任務的本地資料的初始狀態的函式委託。
        //
        //   body:
        //     將為每個迭代呼叫一次的委託。
        //
        //   localFinally:
        //     用於對每個任務的本地狀態執行一個最終操作的委託。
        //
        // 型別引數:
        //   TLocal:
        //     執行緒本地資料的型別。
        //
        // 返回結果:
        //     包含有關已完成的迴圈部分的資訊的結構。
        //
        // 異常:
        //   T:System.ArgumentNullException:
        //     body 引數為 null。- 或 -localInit 引數為 null。- 或 -localFinally 引數為 null。
        //
        //   T:System.AggregateException:
        //     包含在所有執行緒上引發的全部單個異常的異常。
        public static ParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive, Func<TLocal> localInit, Func<int, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally);

 

從上面的程式碼區域中看，你可以看到上面提供了5個引數，而最後意思的就是後面三個，如果你對linq的擴充套件方法比較熟悉的話，你會發現這個其實就是一個並行版本

的累加器（Aggregate）操作，因為他們都是具有三個區域：第一個區域就是初始化區域(localInit)，就是累積之前的一個初始化操作，第二個區域其實就是一個迭代

區域，說白了就是foreach/for迴圈，for迴圈之中，會把計算結果累計到當初初始化區域設定的變數中，第三個區域就是foreach/for之後的一個最終計算區，三者合起

來就是一個並行累加器，為了方便大家更好的理解，我就扒一下原始碼給大家看看:

 

 由於圖太大，就截兩張圖了，大家一定要仔細體會一下這裡面的tlocal變數，因為這個tlocal的使用貫穿著三個區域，所以大家一定要好好體會下面這幾句程式碼

TLocal tLocal = default(TLocal);

tLocal = localInit();

while(xxx<xxx){
tLocal = bodyWithLocal(num5, parallelLoopState, tLocal);
}
localFinally(tLocal);

 

      當你理解了tLocal具有累積foreach中的item結果之後，你就應該很明白下面這個body=>(item, loop, total) 和 finally => (total) 中total的含義了，

對吧，當你明白了，然後大家可以看看下面這段程式碼，是不是用一個方法就搞定了原來需要分階段實現的一個業務邏輯呢？

class Program
{
    static void Main(string[] args)
    {
        List<string> rankList = Enum.GetNames(typeof(FilterType)).ToList();

        var hashCustomerIDList = new HashSet<int>();  //求customerid的並集

        //平行計算 7個 維度的 總和
        Parallel.For(0, rankList.Count, () => { return new List<int>(); }, (item, loop, total) =>
        {
            //業務方法，耗損效能中。。。
            var smallCustomerIDHash = GetXXXMethod(rankList[item]);

            total.AddRange(smallCustomerIDHash);

            return total;
        }, (total) =>
        {
            lock (hashCustomerIDList)
            {
                foreach (var customerID in total)
                {
                    hashCustomerIDList.Add(customerID);
                }
            } 
        });
    }

    static HashSet<int> GetXXXMethod(string rank)
    {
        return new HashSet<int>();
    }

    public enum FilterType
    {
        交易行為 = 1,
        營銷活動 = 2,
        地區 = 4,
        新老客戶 = 8,
        營銷渠道 = 16,
        客戶屬性 = 32,
        客戶分組 = 64,
        商品 = 128
    }
}

   好了，本篇就先說這麼多，希望這個具有並行累加器效果的Parallel.For能夠給你帶來一絲靈感~~~