C＃並行VS.線程代碼的性能

Question

我一直在測試System.Threading.Parallel與線程的性能，我很驚訝地看到並行需要更長的時間才能完成任務，而不是線程。我相信這是由於我對Parallel的知識有限，我剛剛開始閱讀。

我想我會分享一些片段，如果有人可以指出我並行代碼運行速度較慢與線程代碼。還嘗試運行相同的比較來查找素數，並發現並行代碼比線程代碼晚得多。

public class ThreadFactory 
{ 
    int workersCount; 
    private List<Thread> threads = new List<Thread>(); 

    public ThreadFactory(int threadCount, int workCount, Action<int, int, string> action) 
    { 
     workersCount = threadCount; 

     int totalWorkLoad = workCount; 
     int workLoad = totalWorkLoad/workersCount; 
     int extraLoad = totalWorkLoad % workersCount; 

     for (int i = 0; i < workersCount; i++) 
     { 
      int min, max; 
      if (i < (workersCount - 1)) 
      { 
       min = (i * workLoad); 
       max = ((i * workLoad) + workLoad - 1); 
      } 
      else 
      { 
       min = (i * workLoad); 
       max = (i * workLoad) + (workLoad - 1 + extraLoad); 
      } 
      string name = "Working Thread#" + i; 

      Thread worker = new Thread(() => { action(min, max, name); }); 
      worker.Name = name; 
      threads.Add(worker); 
     } 
    } 

    public void StartWorking() 
    { 
     foreach (Thread thread in threads) 
     { 
      thread.Start(); 
     } 

     foreach (Thread thread in threads) 
     { 
      thread.Join(); 
     } 
    } 
} 

下面是程序：

Stopwatch watch = new Stopwatch(); 
watch.Start(); 
int path = 1; 

List<int> numbers = new List<int>(Enumerable.Range(0, 10000)); 

if (path == 1) 
{ 
    Parallel.ForEach(numbers, x => 
    { 
     Console.WriteLine(x); 
     Thread.Sleep(1); 

    }); 
} 
else 
{ 
    ThreadFactory workers = new ThreadFactory(10, numbers.Count, (min, max, text) => { 

     for (int i = min; i <= max; i++) 
     { 
      Console.WriteLine(numbers[i]); 
      Thread.Sleep(1); 
     } 
    }); 

    workers.StartWorking(); 
} 

watch.Stop(); 
Console.WriteLine(watch.Elapsed.TotalSeconds.ToString()); 

Console.ReadLine(); 

更新：

以鎖定考慮：我嘗試下面的代碼片段。同樣的結果，Parallel似乎要慢得多。

path = 1; cieling = 10000000;

List<int> numbers = new List<int>(); 

    if (path == 1) 
    { 
     Parallel.For(0, cieling, x => 
     { 
      lock (numbers) 
      { 
       numbers.Add(x);  
      } 

     }); 
    } 

    else 
    { 
     ThreadFactory workers = new ThreadFactory(10, cieling, (min, max, text) => 
     { 

      for (int i = min; i <= max; i++) 
      { 
       lock (numbers) 
       { 
        numbers.Add(i);  
       }      

      } 
     }); 

     workers.StartWorking(); 
    } 

更新2： 只是一個快速更新，我的機器有四核處理器。所以並行有4個內核可用。

Answer 1

指的一個blog post勵科普塞JR：

Parallel.ForEach是有點複雜，但是。當使用通用的IEnumerable時，處理所需的項目數量不是事先知道的，必須在運行時發現。另外，由於我們沒有直接訪問每個元素，調度程序必須枚舉集合來處理它。 由於IEnumerable不是線程安全的，因此它必須在枚舉時鎖定元素，爲每個塊創建臨時集合以進行處理，並將其計劃到。

鎖定和複製可能會使Parallel.ForEach花費更長的時間。此外，ForEach的分區和調度程序可能會影響併產生開銷。我測試了你的代碼並增加了每個任務的睡眠時間，然後結果更接近，但ForEach仍然較慢。

[編輯 - 更多的研究]

添加以下到執行循環：

if (Thread.CurrentThread.ManagedThreadId > maxThreadId) 
    maxThreadId = Thread.CurrentThread.ManagedThreadId; 

什麼這說明我的機器上是它使用較少用foreach 10個線程，比另一個與當前的設置。如果你想從ForEach中獲得更多的線程，你將不得不使用ParallelOptions和Scheduler。

見Does Parallel.ForEach limits the number of active threads?

Answer 2

我想我可以回答你的問題。首先，你沒有寫出你的系統有多少核心。如果你正在運行一個雙核心的話，那麼當你在線程例子中使用10個線程時，只有4個線程可以使用Parallel.For工作。由於您正在運行的任務（打印+短暫睡眠）對於線程來說是一個非常短的任務，線程開銷與任務相比非常大，所以更多的線程會更好地工作，我幾乎可以肯定，如果您在沒有線程的情況下編寫相同的代碼它會工作得更快。

兩種方法的工作方式都差不多，但如果事先創建所有線程，則將分配保存爲Parallel.For，並使用添加一些移動開銷的任務池。

Answer 3

這個比較對於Threading.Parallel來說並不是很公平。你告訴你的自定義線程池它需要10個線程。 Threading.Parallel不知道它需要多少線程，所以它會在運行時考慮到當前的CPU負載等因素。由於測試中的迭代次數足夠小，因此可以減少此線程的數量。提供Threading.Parallel同樣暗示將使它運行得更快：

 

int workerThreads; 
int completionPortThreads; 
ThreadPool.GetMinThreads(out workerThreads, out completionPortThreads); 
ThreadPool.SetMinThreads(10, completionPortThreads); 
 

Answer 4

這是合乎邏輯的:-)

這將是歷史上的第一次添加的代碼一個（或兩個）層改進的性能。當您使用便利圖書館時，您應該期望付出代價。順便說一句，你還沒有發佈數字。必須發佈結果:-)

爲了讓事情有點更失敗（或偏見:-)爲Parallel-s，將列表轉換爲數組。

然後爲了讓他們完全不公平，請自行拆分工作，製作一個只包含10個項目的數組，並將完全勺子饋送動作分配給並行。你當然在做Parallel-s承諾爲你做的工作，但這肯定是一個有趣的數字:-)

順便說一句我剛剛讀過裏德的博客。在這個問題中使用的分區是他稱之爲最簡單和天真的分區。 這確實是一個很好的消除測試。您仍然需要檢查零工作案例，以瞭解它是否完全被洗淨。