• ConcurrentQueue 是完全无锁的，能够支持并发的添加元素，先进先出

TryDequeue 尝试移除并返回

TryPeek 尝试返回但不移除

Enqueus()： 向队列中加入元素

例子

  1. class Program
  2. {
  3.     private static object o = new object();
  4.     /*定义 Queue*/
  5.     private static Queue<Product> _Products { get; set; }
  6.     private static ConcurrentQueue<Product> _ConcurrenProducts { get; set; }
  7.     /*  coder:释迦苦僧  
  8.      *  代码中 创建三个并发线程 来操作_Products 和 _ConcurrenProducts 集合，每次添加 10000 条数据 查看 一般队列Queue 和 多线程安全下的队列ConcurrentQueue 执行情况
  9.      */
  10.     static void Main(string[] args)
  11.     {
  12.         Thread.Sleep(1000);
  13.         _Products = new Queue<Product>();
  14.         Stopwatch swTask = new Stopwatch();
  15.         swTask.Start();
  17.         /*创建任务 t1  t1 执行 数据集合添加操作*/
  18.         Task t1 = Task.Factory.StartNew(() =>
  19.         {
  20.             AddProducts();
  21.         });
  22.         /*创建任务 t2  t2 执行 数据集合添加操作*/
  23.         Task t2 = Task.Factory.StartNew(() =>
  24.         {
  25.             AddProducts();
  26.         });
  27.         /*创建任务 t3  t3 执行 数据集合添加操作*/
  28.         Task t3 = Task.Factory.StartNew(() =>
  29.         {
  30.             AddProducts();
  31.         });
  33.         Task.WaitAll(t1, t2, t3);
  34.         swTask.Stop();
  35.         Console.WriteLine("List<Product> 当前数据量为：" + _Products.Count);
  36.         Console.WriteLine("List<Product> 执行时间为：" + swTask.ElapsedMilliseconds);
  38.         Thread.Sleep(1000);
  39.         _ConcurrenProducts = new ConcurrentQueue<Product>();
  40.         Stopwatch swTask1 = new Stopwatch();
  41.         swTask1.Start();
  43.         /*创建任务 tk1  tk1 执行 数据集合添加操作*/
  44.         Task tk1 = Task.Factory.StartNew(() =>
  45.         {
  46.             AddConcurrenProducts();
  47.         });
  48.         /*创建任务 tk2  tk2 执行 数据集合添加操作*/
  49.         Task tk2 = Task.Factory.StartNew(() =>
  50.         {
  51.             AddConcurrenProducts();
  52.         });
  53.         /*创建任务 tk3  tk3 执行 数据集合添加操作*/
  54.         Task tk3 = Task.Factory.StartNew(() =>
  55.         {
  56.             AddConcurrenProducts();
  57.         });
  59.         Task.WaitAll(tk1, tk2, tk3);
  60.         swTask1.Stop();
  61.         Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  62.         Console.WriteLine("ConcurrentQueue<Product> 执行时间为：" + swTask1.ElapsedMilliseconds);
  63.         Console.ReadLine();
  64.     }
  66.     /*执行集合数据添加操作*/
  67.     static void AddProducts()
  68.     {
  69.         Parallel.For(0, 30000, (i) =>
  70.         {
  71.             Product product = new Product();
  72.             product.Name = "name" + i;
  73.             product.Category = "Category" + i;
  74.             product.SellPrice = i;
  75.             lock (o)
  76.             {
  77.                 _Products.Enqueue(product);
  78.             }
  79.         });
  81.     }
  82.     /*执行集合数据添加操作*/
  83.     static void AddConcurrenProducts()
  84.     {
  85.         Parallel.For(0, 30000, (i) =>
  86.         {
  87.             Product product = new Product();
  88.             product.Name = "name" + i;
  89.             product.Category = "Category" + i;
  90.             product.SellPrice = i;
  91.             _ConcurrenProducts.Enqueue(product);
  92.         });
  94.     }
  95. }
  97. class Product
  98. {
  99.     public string Name { get; set; }
  100.     public string Category { get; set; }
  101.     public int SellPrice { get; set; }
  102. }