C#中的多線程小試牛刀

來源：本站原創(chuàng)|時間：2020-01-10|欄目：C#教程|點擊：次

前言

昨天在上班時瀏覽博問，發(fā)現(xiàn)了一個問題，雖然自己在 C# 多線程上沒有怎么嘗試過，看了幾遍 CLR 中關(guān)于線程的概念和講解（后面三章）。也想拿來實踐實踐。問題定義是這樣的：

對于多線程不是很懂，面試的時候遇到一個多線程的題，不會做，分享出來，懂的大佬指點一下，謝謝

建一個winform窗體，在窗體中放上一個開始按鈕，一個停止按鈕，一個文本框，在窗體中聲明一個List類型的屬性，點擊開始按鈕后開啟10個線程，所有線程同時不間斷的給List集合中添加1-10000之間的隨機(jī)數(shù)，要求添加List集合中的數(shù)字不能重復(fù)，并且實時在文本框中顯示集合的長度，當(dāng)集合List的長度等于1000時自動停止所有線程，如果中途點擊停止按鈕也停止所有線程，點擊開始又繼續(xù)執(zhí)行。

我其實沒有完全實現(xiàn)了這位博問中提問的同學(xué)的需求，具體問題的來源可查看該地址問題來源

開始嘗試

剛拿到這個需求的時候，映入我腦海里的是 Task, Threadpool，Concurrent，和 Lock 等概念，接下來就是組裝和編碼的過程了，首先理一理頭緒，

生成隨機(jī)數(shù)
插入到 List 中，且不能重復(fù)
開啟多個線程同時插入。

首先是生成隨機(jī)數(shù)，使用 System.Random 類來生成偽隨機(jī)數(shù)（這個其實性能和效率賊低，后面再敘述）

private int GenerateInt32Num()
{
 var num = random.Next(0, TOTAL_NUM);
 return num;
}

然后是插入到 List<Int32> 中的代碼，判斷是否已經(jīng)達(dá)到了我們需要的 List 長度，如果已滿足，則退出程序。

private void AddToList(int num)
{
 if (numList.Count == ENDNUM)
 {
 return;
 }

 numList.Add(num);
}

如果是個單線程的，按照上面那樣 while(true) 然后一直插入即可，可這個是個多線程，那么需要如何處理呢？

我思考了一下，想到了之前在 CLR 中學(xué)到的可以用 CancellationTokenSource 中的 Cancel 來通知 Task 來取消操作。所以現(xiàn)在的邏輯是，用線程池來實現(xiàn)多線程。然后傳入 CancellationTokenSource.Token 來取消任務(wù)。

最后用 Task.WhanAny() 來獲取到第一個到達(dá)此 Task 的 ID。

首先是建立 Task[] 的數(shù)組

internal void DoTheCompeteSecond()
{
 Task[] tasks = new Task[10];

 for (int i = 0; i < 10; ++i)
 {
 int num = i;
 tasks[i] = Task.Factory.StartNew(() => AddNumToList(num, cts), cts.Token);
 }

 Task.WaitAny(tasks);
}

然后 AddNumToList 方法是這樣定義的，

private void AddNumToList(object state, CancellationTokenSource cts)
{-
 Console.WriteLine("This is the {0} thread,Current ThreadId={1}",
   state,
   Thread.CurrentThread.ManagedThreadId);

 while (!cts.Token.IsCancellationRequested)
 {
 if (GetTheListCount() == ENDNUM)
 {
  cts.Cancel();
  Console.WriteLine("Current Thread Id={0},Current Count={1}",
    Thread.CurrentThread.ManagedThreadId,
    GetTheListCount());

  break;
 }
 var insertNum = GenerateInt32Num();
 if (numList.Contains(insertNum))
 {
  insertNum = GenerateInt32Num();
 }

 AddToList(insertNum);
 }
}

看起來是沒有什么問題的，運(yùn)行了一下。得到了如下結(jié)果，

這應(yīng)該是昨晚運(yùn)行時得到的數(shù)據(jù)，當(dāng)時也沒有多想，就貼了上去，回答了那位提問同學(xué)的問題。但是心里有一個疑惑，為什么會同時由兩個 Thread 同時達(dá)到了該目標(biāo)呢？

發(fā)現(xiàn)問題

今天早上到公司時，我又打開了這個代碼，發(fā)現(xiàn)確實有點不對勁，于是就和我邊上做 Go 語言開發(fā)的同學(xué)，問了問他，哪里出現(xiàn)了問題，他和我說：“你加了讀寫鎖了嗎?” 你這里有數(shù)據(jù)臟讀寫。心里面有了點眉目。

按照他說的，修改了一下AddToList 里面的邏輯，這時候，確實解決了上面的問題，

private void AddToList(int num)
{
 rwls.EnterReadLock();
 if (numList.Count == ENDNUM)
 return;
 rwls.ExitReadLock();

 rwls.EnterWriteLock();
 numList.Add(num);
 rwls.ExitWriteLock();
}

得到的結(jié)果如下：

完整的代碼如下所示：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace CSharpFundamental
{
 class MultipleThreadCompete
 {
 List<int> numList = new List<int>();
 Random random = new Random();
 CancellationTokenSource cts = new CancellationTokenSource();
 private const int ENDNUM = 1000000;

 ReaderWriterLockSlim rwls = new ReaderWriterLockSlim();

 internal void DoTheCompeteSecond()
 {
  Stopwatch sw = new Stopwatch();
  sw.Start();
  Task[] tasks = new Task[100];

  for (int i = 0; i < 100; ++i)
  {
  int num = i;
  tasks[i] = Task.Run(() => AddNumToList(num, cts), cts.Token);
  }

  Task.WaitAny(tasks);

  Console.WriteLine("ExecuteTime={0}", sw.ElapsedMilliseconds / 1000);
 }

 private int GetTheListCount()
 {
  return numList.Count;
 }

 private void AddToList(int num)
 {
  rwls.EnterReadLock();
  if (numList.Count == ENDNUM)
  return;
  rwls.ExitReadLock();

  rwls.EnterWriteLock();
  numList.Add(num);
  rwls.ExitWriteLock();
 }

 private void AddNumToList(object state, CancellationTokenSource cts)
 {
  Console.WriteLine("This is the {0} thread,Current ThreadId={1}",
  state,
  Thread.CurrentThread.ManagedThreadId);

  while (!cts.Token.IsCancellationRequested)
  {
  try
  {
   rwls.EnterReadLock();
   if (numList.Count == ENDNUM)
   {
   cts.Cancel();
   Console.WriteLine("Current Thread Id={0},Current Count={1}",
    Thread.CurrentThread.ManagedThreadId,
    GetTheListCount());
   break;
   }
  }
  finally
  {
   rwls.ExitReadLock();
  }

  var insertNum = GenerateInt32Num();
  if (numList.Contains(insertNum))
  {
   insertNum = GenerateInt32Num();
  }

  AddToList(insertNum);
  }
 }

 private int GenerateInt32Num()
 {
  return random.Next(1, ENDNUM);
 }
 }
}

這時候，那位 Go 語言的同學(xué)和我說，我們試試 1000w 的數(shù)據(jù)插入，看看需要多少時間？于是我讓他用 Go 語言實現(xiàn)了一下上面的邏輯，1000w數(shù)據(jù)用了三分鐘，我讓他看看總共生成了多少隨機(jī)數(shù)，他查看了一下生成了 1億4千多萬的數(shù)據(jù)。

最開始我用上面的代碼來測，發(fā)現(xiàn)我插入 1000w 的數(shù)據(jù)，CPU 到100% 而且花了挺長時間，程序根本沒反應(yīng)，查看了一下我判斷重復(fù)的語句numList.Contains()

底層實現(xiàn)的代碼為:

[__DynamicallyInvokable]
 public bool Contains(T item)
 {
  if ((object) item == null)
  {
   for (int index = 0; index < this._size; ++index)
   {
    if ((object) this._items[index] == null)
     return true;
   }
   return false;
  }
  EqualityComparer<T> equalityComparer = EqualityComparer<T>.Default;
  for (int index = 0; index < this._size; ++index)
  {
   if (equalityComparer.Equals(this._items[index], item))
    return true;
  }
  return false;
 }

可想而知，如果數(shù)據(jù)量很大的話，這個循環(huán)不就及其緩慢嗎？

我于是請教了那位 GO 的同學(xué)，判斷重復(fù)的邏輯用什么來實現(xiàn)的，他和我說了一個位圖 bitmap 的概念，

我用其重寫了一下判斷重復(fù)的邏輯，代碼如下：

int[] bitmap = new int[MAX_SIZE]；

var index = num % TOTAL_NUM;
bitMap[index] = 1;

return bitMap[num] == 1;

在添加到 List 的時候，順便插入到 bitmap 中，判斷重復(fù)只需要根據(jù)當(dāng)前元素的位置是否等于 1 即可，

我修改代碼后，跑了一下 1000w 的數(shù)據(jù)用來 3000+ ms。

這時候，引起了他的極度懷疑，一向以高性能并發(fā) 著稱的 Go 速度竟然這么慢嗎？他一度懷疑我的邏輯有問題。

下午結(jié)束了一個階段的工作后，我又拾起了我上午寫的代碼，果不其然，發(fā)現(xiàn)了邏輯錯誤：

如下：

var insertNum = GenerateInt32Num();
if (numList.Contains(insertNum))
{
 insertNum = GenerateInt32Num();
}

生成隨機(jī)數(shù)這里，這里有個大問題，就是其實只判斷了一次，導(dǎo)致速度那么快，正確的寫法應(yīng)該是

while (ContainsNum(currentNum))
{
 currentNum = GenerateInt32Num();
}

private int GenerateInt32Num()
{
 var num = random.Next(0, TOTAL_NUM);
 //Console.WriteLine(num);

 return num;
}

最后的代碼如下：

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

namespace CSharpFundamental
{
 class MultipleThreadCompete
 {
  List<int> numList = new List<int>();
  Random random = new Random();
  CancellationTokenSource cts = new CancellationTokenSource();
  private const int TOTAL_NUM = 1000000;
  private const int CURRENT_THREAD_COUNT = 35;

  ReaderWriterLockSlim rwls = new ReaderWriterLockSlim();

  int[] bitMap = new int[TOTAL_NUM];

  internal void DoTheCompete()
  {
   //ThreadPool.SetMinThreads(CURRENT_THREAD_COUNT, CURRENT_THREAD_COUNT);
   Stopwatch sw = new Stopwatch();
   sw.Start();
   Task[] tasks = new Task[CURRENT_THREAD_COUNT];

   for (int i = 0; i < CURRENT_THREAD_COUNT; ++i)
   {
    int num = i;
    tasks[i] = Task.Run(() => ExecuteTheTask(num, cts), cts.Token);
   }

   Task.WaitAny(tasks);

   Console.WriteLine("ExecuteTime={0}", sw.ElapsedMilliseconds);
  }

  private int GetTheListCount()
  {
   return numList.Count;
  }

  private void AddToList(int num)
  {
   if (numList.Count == TOTAL_NUM)
    return;
   numList.Add(num);

   var index = num % TOTAL_NUM;
   bitMap[index] = 1;
  }

  private void ExecuteTheTask(object state, CancellationTokenSource cts)
  {
   Console.WriteLine("This is the {0} thread,Current ThreadId={1}",
    state,
    Thread.CurrentThread.ManagedThreadId);

   while (!cts.Token.IsCancellationRequested)
   {
    try
    {
     rwls.EnterReadLock();
     if (numList.Count == TOTAL_NUM)
     {
      cts.Cancel();
      Console.WriteLine("Current Thread Id={0},Current Count={1}",
       Thread.CurrentThread.ManagedThreadId,
       GetTheListCount());
      break;
     }
    }
    finally
    {
     rwls.ExitReadLock();
    }

    var currentNum = GenerateInt32Num();

    while (ContainsNum(currentNum))
    {
     currentNum = GenerateInt32Num();
    }

    rwls.EnterWriteLock();
    AddToList(currentNum);
    rwls.ExitWriteLock();
   }
  }

  private int GenerateInt32Num()
  {
   var num = random.Next(0, TOTAL_NUM);
   //Console.WriteLine(num);

   return num;
  }

  private bool ContainsNum(int num)
  {
   rwls.EnterReadLock();
   var contains = bitMap[num] == 1;
   rwls.ExitReadLock();

   return contains;
  }
 }
}

結(jié)果如下：

但是這個代碼執(zhí)行 1000w的數(shù)據(jù)需要好久。這個問題繼續(xù)研究。

源碼地址：https://github.com/doublnt/dotnetcore/tree/master/CSharpFundamental

總結(jié)

以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，謝謝大家對我們的支持。

上一篇：C#實現(xiàn)類型的比較示例詳解

欄目：C#教程

下一篇：C#多線程中的異常處理操作示例

本文標(biāo)題：C#中的多線程小試牛刀

本文地址：http://mengdiqiu.com.cn/a1/C_jiaocheng/4763.html

更多C#教程

欧美大屁股bbbbxxxx,狼人大香伊蕉国产www亚洲,男ji大巴进入女人的视频小说,男人把ji大巴放进女人免费视频,免费情侣作爱视频

C#教程

C#中的多線程小試牛刀

您可能感興趣的文章

閱讀排行

本欄相關(guān)

隨機(jī)閱讀