介绍四大并发集合类并结合单例模式下的队列来说明线程安全和非安全的场景及补充性能调优问题。

一. 四大并发集合类

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

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        

代码结果：

更多C++后台开发技术点知识内容包括C/C++，Linux，Nginx，ZeroMQ，MySQL，Redis，MongoDB，ZK，流媒体，音视频开发，Linux内核，TCP/IP，协程，DPDK多个高级知识点。

C/C++Linux服务器开发高级架构师/C++后台开发架构师​免费学习地址

【文章福利】另外还整理一些C++后台开发架构师 相关学习资料，面试题，教学视频，以及学习路线图，免费分享有需要的可以点击领取

二. 队列的综合案例

上面介绍了四大安全线程集合类和与其对应的不安全的线程集合类，可能你会比较疑惑，到底怎么安全了，那些不安全的集合类怎么能变成安全呢，下面以队列为例，来解决这些疑惑。

　　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，显然是正确的。

 1             {
 2                 Queue queue = new Queue();
 3                 object o = new object();
 4                 int count = 0;
 5                 List<Task> taskList = new List<Task>();
 6                 for (int i = 0; i < 100; i++)
 7                 {
 8                     var task = Task.Run(() =>
 9                     {
10                         lock (o)
11                         {
12                             queue.Enqueue(count++);
13                         }
14                     });
15                     taskList.Add(task);
16                 }
17 
18                 Task.WaitAll(taskList.ToArray());
19                 //发现队列个数在全是100
20                 Console.WriteLine("Queue加锁的情况队列个数" + queue.Count);
21             }

③. ConcurrentQueue不加锁的情况：结果全是100，显然是正确，同时证明ConcurrentQueue队列本身就是线程安全的。

 1             {
 2                 ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
 3                 object o = new object();
 4                 int count = 0;
 5                 List<Task> taskList = new List<Task>();
 6 
 7                 for (int i = 0; i < 100; i++)
 8                 {
 9                     var task = Task.Run(() =>
10                     {
11                         queue.Enqueue(count++);
12                     });
13                     taskList.Add(task);
14                 }
15                 Task.WaitAll(taskList.ToArray());
16                 //发现队列个数不加锁的情形=也全是100，证明ConcurrentQueue是线程安全的
17                 Console.WriteLine("ConcurrentQueue不加锁的情况下队列个数" + queue.Count);
18             }

　　3. 在实际项目中，如果使用队列来实现一个业务，该队列需要是全局的，这个时候就需要使用单例(ps：单例是不允许被实例化的，可以通过单例类中的属性或者方法的形式来获取这个类)，同时，队列的入队和出队操作，如果使用Queue队列，需要配合lock锁，来解决多线程下资源的竞用问题。

　　经典案例：开启100个线程对其进行入队操作，然后主线程输入队列的个数，并且将队列中的内容输出.

　　结果：队列的个数为100，输出内容1-100依次输出。

单例类

 1 /// <summary>
 2     /// 单例类
 3     /// </summary>
 4     public class QueueUtils
 5     {
 6         /// <summary>
 7         /// 静态变量：由CLR保证，在程序第一次使用该类之前被调用，而且只调用一次
 8         /// </summary>
 9         private static readonly QueueUtils _QueueUtils = new QueueUtils();
10 
11         /// <summary>
12         /// 声明为private类型的构造函数，禁止外部实例化
13         /// </summary>
14         private QueueUtils()
15         {
16 
17         }
18         /// <summary>
19         /// 声明属性，供外部调用，此处也可以声明成方法
20         /// </summary>
21         public static QueueUtils instanse
22         {
23             get
24             {
25                 return _QueueUtils;
26             }
27         }
28 
29 
30         //下面是队列相关的
31         Queue queue = new Queue();
32 
33         private static object o = new object();
34 
35         public  int getCount()
36         {
37             return queue.Count;
38         }
39 
40         /// <summary>
41         /// 入队方法
42         /// </summary>
43         /// <param name="myObject"></param>
44         public void Enqueue(object myObject)
45         {
46             lock (o)
47             {
48                 queue.Enqueue(myObject);
49             }
50         }
51         /// <summary>
52         /// 出队操作
53         /// </summary>
54         /// <returns></returns>
55         public object Dequeue()
56         {
57             lock (o)
58             {
59                 if (queue.Count > 0)
60                 {
61                     return queue.Dequeue();
62                 }
63             }
64             return null;
65         }
66 
67     }

出入队操作

 1   {
 2                 int count = 1;
 3                 List<Task> taskList = new List<Task>();
 4                 for (int i = 0; i < 100; i++)
 5                 {
 6                     var task = Task.Run(() =>
 7                     {
 8                         QueueUtils.instanse.Enqueue(count++);
 9                     });
10                     taskList.Add(task);
11                 }
12 
13                 Task.WaitAll(taskList.ToArray());
14                 //发现队列个数在全是100
15                 Console.WriteLine("单例模式下队列个数" + QueueUtils.instanse.getCount());
16 
17                 //下面是出队相关的业务
18                 while (QueueUtils.instanse.getCount() > 0)
19                 {
20                     Console.WriteLine("出队：" + QueueUtils.instanse.Dequeue());
21                 }
22             }

。。。。。。。。。。。

三. 常见的几类性能调优

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. 运用设计模式，使代码简洁、易于扩展。

原文链接：第十四节: 介绍四大并发集合类并结合单例模式下的队列来说明线程安全和非安全的场景及补充性能调优问题。