第十四節: 介紹四大並發集合類並結合單例模式下的隊列來說明線程安全和非安全的場景及補充性能調優問題。

一. 四大並發集合類

背景：我們目前使用的所有集合都是線程不安全的 。

　　A. ConcurrentBag：就是利用線程槽來分攤Bag中的所有數據，鏈表的頭插法,0代表移除最后一個插入的值.

　　(等價於同步中的List)

　　B. ConcurrentStack：線程安全的Stack是使用Interlocked來實現線程安全, 而沒有使用內核鎖.

　　(等價於同步中的數組)

　　C. ConcurrentQueue: 隊列的模式，先進先出

　　(等價於同步中的隊列)

　　D. ConcurrentDictionary: 字典的模式

　　(等價於同步中的字典)

以上四種安全的並發集合類，也可以采用同步版本+Lock鎖(或其它鎖)來實現

 代碼實踐：

          01-ConcurrentBag
            {
                Console.WriteLine("---------------- 01-ConcurrentBag ---------------------");
                ConcurrentBag<int> bag = new ConcurrentBag<int>();
                bag.Add(1);
                bag.Add(2);
                bag.Add(33);
                //鏈表的頭插法,0代表移除最后一個插入的值
                var result = 0;
                //flag為true，表示移除成功，並且返回被移除的值
                var flag = bag.TryTake(out result);
                Console.WriteLine("移除的值為：{0}", result);

            }
            #endregion

             02-ConcurrentStack
            {
                Console.WriteLine("---------------- 02-ConcurrentStack ---------------------");
                ConcurrentStack<int> stack = new ConcurrentStack<int>();
                stack.Push(1);
                stack.Push(2);
                stack.Push(33);
                //鏈表的頭插法,0代表移除最后一個插入的值
                var result = 0;
                //flag為true，表示移除成功，並且返回被移除的值
                var flag = stack.TryPop(out result);

                Console.WriteLine("移除的值為：{0}", result);
            }
            #endregion

            03-ConcurrentQueue
            {
                Console.WriteLine("---------------- 03-ConcurrentQueue ---------------------");
                ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
                queue.Enqueue(1);
                queue.Enqueue(2);
                queue.Enqueue(33);
                //隊列的模式，先進先出，0代表第一個插入的值
                var result = 0;
                //flag為true，表示移除成功，並且返回被移除的值
                var flag = queue.TryDequeue(out result);

                Console.WriteLine("移除的值為：{0}", result);
            }
            #endregion

             04-ConcurrentDictionary
            {
                Console.WriteLine("---------------- 04-ConcurrentDictionary ---------------------");
                ConcurrentDictionary<int, int> dic = new ConcurrentDictionary<int, int>();
                dic.TryAdd(1, 10);
                dic.TryAdd(2, 11);
                dic.TryAdd(3, 12);
                dic.ContainsKey(3);
                //下面是輸出字典中的所有值
                foreach (var item in dic)
                {
                    Console.WriteLine(item.Key + item.Value);
                }
            }
            #endregion        

代碼結果：

 

二. 隊列的綜合案例

 　　上面介紹了四大安全線程集合類和與其對應的不安全的線程集合類，可能你會比較疑惑，到底怎么安全了，那些不安全的集合類怎么能變成安全呢，下面以隊列為例，來解決這些疑惑。

　　1. 測試Queue隊列並發情況下是不安全的(存在資源競用的問題)，ConcurrentQueue隊列在並發情況下是安全的。

　　2. 利用Lock鎖+Queue隊列，實現多線程並發情況下的安全問題，即等同於ConcurrentQueue隊列的效果。

　　　　經典案例測試：開啟100個線程進行入隊操作，正常所有的線程執行結束后，隊列中的個數應該為100.

　　　　①. Queue不加鎖的情況：結果出現99、98、100，顯然是出問題了。

            {
                Queue queue = new Queue();
                object o = new object();
                int count = 0;
                List<Task> taskList = new List<Task>();
                for (int i = 0; i < 100; i++)
                {
                    var task = Task.Run(() =>
                      {
                          queue.Enqueue(count++);
                      });
                    taskList.Add(task);
                }

                Task.WaitAll(taskList.ToArray());
                //發現隊列個數在不加鎖的情況下 竟然不同 有100，有99
                Console.WriteLine("Queue不加鎖的情況隊列個數" + queue.Count);
            }

　　　　②. Queue加鎖的情況：結果全是100，顯然是正確的。

            {
                Queue queue = new Queue();
                object o = new object();
                int count = 0;
                List<Task> taskList = new List<Task>();
                for (int i = 0; i < 100; i++)
                {
                    var task = Task.Run(() =>
                    {
                        lock (o)
                        {
                            queue.Enqueue(count++);
                        }
                    });
                    taskList.Add(task);
                }

                Task.WaitAll(taskList.ToArray());
                //發現隊列個數在全是100
                Console.WriteLine("Queue加鎖的情況隊列個數" + queue.Count);
            }

　　　　③. ConcurrentQueue不加鎖的情況：結果全是100，顯然是正確，同時證明ConcurrentQueue隊列本身就是線程安全的。

            {
                ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
                object o = new object();
                int count = 0;
                List<Task> taskList = new List<Task>();

                for (int i = 0; i < 100; i++)
                {
                    var task = Task.Run(() =>
                    {
                        queue.Enqueue(count++);
                    });
                    taskList.Add(task);
                }
                Task.WaitAll(taskList.ToArray());
                //發現隊列個數不加鎖的情形=也全是100，證明ConcurrentQueue是線程安全的
                Console.WriteLine("ConcurrentQueue不加鎖的情況下隊列個數" + queue.Count);
            }

　　3. 在實際項目中，如果使用隊列來實現一個業務，該隊列需要是全局的，這個時候就需要使用單例(ps：單例是不允許被實例化的，可以通過單例類中的屬性或者方法的形式來獲取這個類)，同時，隊列的入隊和出隊操作，如果使用Queue隊列，需要配合lock鎖，來解決多線程下資源的競用問題。

　　經典案例：開啟100個線程對其進行入隊操作，然后主線程輸入隊列的個數，並且將隊列中的內容輸出.

　　結果：隊列的個數為100，輸出內容1-100依次輸出。

/// <summary>
    /// 單例類
    /// </summary>
    public class QueueUtils
    {
        /// <summary>
        /// 靜態變量：由CLR保證，在程序第一次使用該類之前被調用，而且只調用一次
        /// </summary>
        private static readonly QueueUtils _QueueUtils = new QueueUtils();

        /// <summary>
        /// 聲明為private類型的構造函數，禁止外部實例化
        /// </summary>
        private QueueUtils()
        {

        }
        /// <summary>
        /// 聲明屬性，供外部調用，此處也可以聲明成方法
        /// </summary>
        public static QueueUtils instanse
        {
            get
            {
                return _QueueUtils;
            }
        }


        //下面是隊列相關的
        Queue queue = new Queue();

        private static object o = new object();

        public  int getCount()
        {
            return queue.Count;
        }

        /// <summary>
        /// 入隊方法
        /// </summary>
        /// <param name="myObject"></param>
        public void Enqueue(object myObject)
        {
            lock (o)
            {
                queue.Enqueue(myObject);
            }
        }
        /// <summary>
        /// 出隊操作
        /// </summary>
        /// <returns></returns>
        public object Dequeue()
        {
            lock (o)
            {
                if (queue.Count > 0)
                {
                    return queue.Dequeue();
                }
            }
            return null;
        }

    }

  {
                int count = 1;
                List<Task> taskList = new List<Task>();
                for (int i = 0; i < 100; i++)
                {
                    var task = Task.Run(() =>
                    {
                        QueueUtils.instanse.Enqueue(count++);
                    });
                    taskList.Add(task);
                }

                Task.WaitAll(taskList.ToArray());
                //發現隊列個數在全是100
                Console.WriteLine("單例模式下隊列個數" + QueueUtils.instanse.getCount());

                //下面是出隊相關的業務
                while (QueueUtils.instanse.getCount() > 0)
                {
                    Console.WriteLine("出隊：" + QueueUtils.instanse.Dequeue());
                }
            }

。。。。。。。。。。。

三. 常見的幾類性能調優

PS： 

1. 常見的一級事件：CPU占用過高、死鎖問題、內存爆滿
　　a. CPU過高：查看是否while(true)中的業務過於復雜，導致cpu一直在高負荷運行。
　　b. 死鎖問題：亂用lock，千萬不要lock中再加lock，多個lock重疊
　　c. 內存爆滿：字符串的無限增長，全局的靜態變量過多。
2. 補充幾個常用的性能調優的方式
　　a. 使用字典類型Dictionary<T,T>，代替只有兩個屬性的對象或匿名對象。
　　b. 使用數組代替只有兩個屬性的對象或匿名對象。
　　比如：
　　　　index：存放id
　　　　value：存放數量或其他屬性
3. 返璞歸真，使用最原始的代碼代替簡潔漂亮的代碼。
4. 合理的使用多線程，業務復雜的盡可能的並發執行(或者異步)。
5. 運用設計模式，使代碼簡潔、易於擴展。

 

 

 

!

• 作       者 : Yaopengfei(姚鵬飛)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 聲     明1 : 本人才疏學淺，用郭德綱的話說“我是一個小學生”，如有錯誤，歡迎討論，請勿謾罵^_^。
• 聲     明2 : 原創博客請在轉載時保留原文鏈接或在文章開頭加上本人博客地址，否則保留追究法律責任的權利。