接上文 多线程编程学习笔记——使用并发集合（一）

 

二、   使用ConcurrentQueue来实现异步处理

本示例将学习如何创建一个能被多个线程异步处理的一组任务的例子。

 一、程序示例代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Collections.Concurrent;
  7. using System.Diagnostics;
  8. using System.Threading; 
  10. namespace ThreadCollectionDemo
  11. {
  13.     class Program
  14.     {
  15.         const string item = "Dict Name";
  16.         public static string CurrentItem;
  17.         static double time1;
  18.         static void Main(string[] args)
  19.         {
  20.             Console.WriteLine(string.Format("-----  ConcurrentQueue 操作----"));
  22.             Task task = TaskRun1();
  23.             task.Wait();
  25.             Console.Read();
  26.         }
  28.         private static async Task TaskRun1()
  29.         {
  31.             var queue = new ConcurrentQueue<CustomTask>();
  32.             var cts = new CancellationTokenSource();
  33.             var taskSrc = Task.Run(() => TaskProduct(queue));
  34.             Task[] process = new Task[4];
  35.             for (int i = 1; i <= 4; i++)
  36.             {
  37.                 string processId = i.ToString();
  38.                 process[i - 1] = Task.Run(() => TaskProcess(queue, "Processer " + processId, cts.Token));
  39.             }
  40.             await taskSrc;
  41.             cts.CancelAfter(TimeSpan.FromSeconds(2));
  42.             await Task.WhenAll(process);
  43.         }
  44.  
  46.         static async Task TaskProduct(ConcurrentQueue<CustomTask> queue)
  47.         {
  48.             for (int i = 0; i < 20; i++)
  49.             {
  50.                 await Task.Delay(50);
  51.                 var workitem = new CustomTask { Id = i };
  52.                 queue.Enqueue(workitem);
  53.                 Console.WriteLine(string.Format("把{0} 元素添加到ConcurrentQueue",workitem.Id));
  54.             }
  55.         }
  57.         static async Task TaskProcess(ConcurrentQueue<CustomTask> queue,string name,CancellationToken token)
  58.         {
  59.             CustomTask workitem;
  60.             bool dequeueSuccesfl = false;
  61.             await GetRandomDely();
  62.             do
  63.             {
  64.                 dequeueSuccesfl = queue.TryDequeue(out workitem);
  66.                 if (dequeueSuccesfl)
  67.                 {
  68.                     Console.WriteLine(string.Format("元素 {0} 从ConcurrentQueue中取出 ，名称：{1} ", workitem.Id, name));
  70.                 }
  72.                 await GetRandomDely();
  73.             }
  75.             while (!token.IsCancellationRequested);
  76.         }
  78.         static Task GetRandomDely()
  79.         {
  80.             int dely = new Random(DateTime.Now.Millisecond).Next(1, 1000);
  81.             return Task.Delay(dely);
  82.         }
  83.  
  84.     }
  86.     public class CustomTask
  87.     {
  88.         public int Id { get; set; }
  89.     }
  90. }
  92.

 

 2.程序运行结果如下图。

      当程序运行时，我们使用ConcurrentQueue集合实现创建了一个任务队列。然后创建了一个取消标志，它是用来在我们将任务放入队列后停止工作 的。接下来启动了一个单独的工作线程来将任务放入任务队列中。这部分分为异步处理产生了工作 量。

       现在定义这个程序中消费任务的部分。我们创建了四个工作 线程，它们会随机等待一段时间，然后从任务队列中获取一个任务，处理这个任务，一直重复整个过程直到我们发出取消标志信号。最后，我们启动产生任务的线程，等待这个线程完成。然后使用取消标志给消费发信号 我们完成了工作。最后一步将等待所有的消费完成。

       我们看到队列中的任务按从前到后的顺序被 处理，但一个后面的任务是有可能会比前面的任务先处理的，因为我们有四个工作 线程独立地运行，而且任务处理时间并不是恒定的。我们看到 访问这个队列是线程安全的，没有一个元素会被提取两次。

 

 

二、   改变ConcurrentStack异步处理顺序

      本示例是对上一面的示例的修改版。我们又一次创建了被多个工作线程异步处理的一组任务，但是这次使用ConcurrentStack来实现，我们来看看这两个示例会有什么不同。

 1. 程序的代码如下图。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Collections.Concurrent;
  7. using System.Diagnostics;
  8. using System.Threading; 
  10. namespace ThreadCollectionDemo
  11. {
  13.     class Program
  14.     {       
  16.         static void Main(string[] args)
  17.         {
  18.             Console.WriteLine(string.Format("-----  ConcurrentStack 操作----"));
  19.             Task task = TaskStack();
  20.             task.Wait();
  21.             Console.Read();
  22.         }
  24.         private static async Task TaskStack()
  25.         { 
  27.             var stack = new ConcurrentStack<CustomTask>();
  28.             var cts = new CancellationTokenSource();
  29.             var taskSrc = Task.Run(() => TaskProduct(stack));
  30.             Task[] process = new Task[4];
  31.             for (int i = 1; i <= 4; i++)
  32.             {
  33.                 string processId = i.ToString();
  34.                 process[i - 1] = Task.Run(() => TaskProcess(stack, "Processer " + processId, cts.Token));
  35.             }
  37.             await taskSrc;
  38.             cts.CancelAfter(TimeSpan.FromSeconds(2));
  39.             await Task.WhenAll(process);
  40.         }
  41.  
  43.         static async Task TaskProduct(ConcurrentStack<CustomTask> stack)
  44.         {
  45.             for (int i = 0; i < 20; i++)
  46.             {
  47.                 await Task.Delay(50);
  48.                 var workitem = new CustomTask { Id = i };
  49.                 stack.Push(workitem);
  50.                 Console.WriteLine(string.Format("把{0} 元素添加到ConcurrentStack",workitem.Id));
  51.             }
  52.         }
  54.         static async Task TaskProcess(ConcurrentStack<CustomTask> stack,string name,CancellationToken token)
  55.         {
  57.             CustomTask workitem;
  58.             bool popSuccesful = false;
  59.             await GetRandomDely();
  60.             do
  61.             {
  62.                 popSuccesful = stack.TryPop(out workitem);
  63.                 if (popSuccesful)
  64.                 {
  65.                     Console.WriteLine(string.Format("元素 {0} ConcurrentStack  取出 ，名称：{1} ", workitem.Id, name));
  66.                 }
  67.                 await GetRandomDely();
  68.             }
  69.             while (!token.IsCancellationRequested);
  70.         }
  72.         static Task GetRandomDely()
  73.         {
  74.             int dely = new Random(DateTime.Now.Millisecond).Next(1, 1000);
  75.             return Task.Delay(dely);
  76.         } 
  77.     } 
  78. }
  80.  
  82.

 

 2.程序的运行结果如下图。

        当程序运行时，我们创建了一个ConcurrentStack集合的实例。其余的代码与前一示例几乎一样，唯一不同之年是我们对并发堆栈使用了Push和TryPop方法，而对并发队列使用Enqueue和TryDequeue方法。

       从上图结果中可以扯到任务处理的顺序被改变了。堆栈是一个LIFO集合，工作线程先处理最近的任务。在并发队列中，任务被处理的顺序与被添加的顺序几乎一样。这说明根据工作线程的数量，我们将在一定时间内处理先被创建的任务。而在堆栈中，早先创建的任务具有较低的优先级，而且直到生产者停止向堆栈中放入更多任务后，这个任务才有可能被处理。这行为是确定 的，最好在这种场景下使用队列。

 

 

版权声明：本文为chillsrc原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/chillsrc/p/8242502.html