C#中那些常见的消费队列使用（上）

二点

一 背景

在我们的工作中我们经常有一种场景就是要使用到队列，特别是对于这样的一种情况：就是生产的速度明显快于消费的速度,而且在多线程的环境下消息的生产由多个线程产生消息的消费则没有这种限制，通过使用队列这种方式能够很大程度上将多线程的问题通过入队的方式变成单个线程内的消息的聚合，然后通过单独的线程进行消费，本篇文章我将介绍一种常见通过包装C#中Queue的方式实现一个能够通过外部增加队列元素，并且由外部进行队列的终止的一种常见的CustomQueue,后面会通过对源码的讲解来一步步加深对基础原理的理解，最后会通过几个单元测试来验证对应的使用。
二 原理讲解

2.1 源代码展示

1. using System;
2. using System.Collections.Generic;
3. using System.Threading;
5. namespace Pangea.Common.Utility.Buffer
6. {
7.     public sealed class ConsumeQueue<T>
8.     {
9.         public static int _Counter_Instance;
11.         public enum ConsumeState
12.         {
13.             Idle,
14.             Consuming,
15.             Terminated
16.         }
18.         private Queue<T> _queue;
20.         private int _threadCounter = 0;
22.         private object _lock = new object();
23.         private Action<T> _consumeAction;
24.         private Action _onTerminatedNotify;
25.         private Func<bool> _shouldTerminateConsume;
27.         public ConsumeState State { get; private set; }
29.         public int PeedingItemsCount
30.         {
31.             get
32.             {
33.                 lock (_lock)
34.                 {
35.                     if (_queue == null)
36.                     {
37.                         return 0;
38.                     }
39.                     else
40.                     {
41.                         return _queue.Count;
42.                     }
43.                 }
44.             }
45.         }
47.         public ConsumeQueue(Action<T> consume, Func<bool> shouldTerminate, Action onTerminated)
48.         {
49.             Interlocked.Increment(ref _Counter_Instance);
51.             _queue = new Queue<T>();
53.             State = ConsumeState.Idle;
55.             _consumeAction = consume;
56.             _shouldTerminateConsume = shouldTerminate;
57.             _onTerminatedNotify = onTerminated;
58.         }
60.         ~ConsumeQueue()
61.         {
62.             Interlocked.Decrement(ref _Counter_Instance);
63.         }
65.         public void ProduceItem(T item)
66.         {
67.             lock (_lock)
68.             {
69.                 if (State == ConsumeState.Terminated) return;
71.                 _queue.Enqueue(item);
73.                 if (State == ConsumeState.Idle)
74.                 {
75.                     State = ConsumeState.Consuming;
76.                     StartConsuming();
77.                 }
78.             }
79.         }
81.         private void StartConsuming()
82.         {
83.             ThreadPool.QueueUserWorkItem(_ =>
84.             {
85.                 ++_threadCounter;
86.                 while (true)
87.                 {
88.                     T newData = default(T);
89.                     lock (_lock)
90.                     {
91.                         newData = _queue.Dequeue();
92.                     }
94.                     _consumeAction(newData);
96.                     lock (_lock)
97.                     {
98.                         if (_shouldTerminateConsume())
99.                         {
100.                             OnTerminated();
101.                             State = ConsumeState.Terminated;
103.                             break;
104.                         }                        
105.                         else if (_queue.Count == 0)
106.                         {
107.                             State = ConsumeState.Idle;
109.                             break;
110.                         }                     
111.                     }
112.                 }
113.                 --_threadCounter;
114.             });
115.         }
117.         private void OnTerminated()
118.         {
119.             _queue.Clear();
120.             _queue = null;
122.             _consumeAction = null;
123.             _shouldTerminateConsume = null;
125.             _onTerminatedNotify?.Invoke();
126.         }
127.     }
128. }

复制代码

2.2 代码解析

• 增加泛型定义和类类型
  

首先对于该类作为一个完整的工具类,所以该类设计为禁止被继承和重写，所以增加C#关键字sealed作为一个密封类，另外对于该类中定义的数据类型并没有明确的规定，所以该类设计成一个泛型类并且没有对该类型T做一个明确的类型限制，这个在一定程度上增加了该类的灵活性。

• 定义ConsumeQueue中内部执行状态
  在实际的代码中通过下面的一个枚举类型State来定义内部执行状态
  

1. public enum ConsumeState
2.         {
3.             Idle,
4.             Consuming,
5.             Terminated
6.         }

复制代码

• A 当CustomQueue初始化或者其内部的消息队列Queue被清除完毕的时候设置状态为Idle状态并退出StartConsuming方法中的消费循环中
  
• B 当内部的消息队列中存在未被消费的项目时启动消费过程，并设置State为Consuming
  
• C 当外部传入的ShouldTerminateConsume触发时则不论内部的待消费的队列是否为空都将退出当前消费过程，并调用内部的OnTerminated方法清除所有消费队列对象
  

2.3 对应的单元测试

单元测试部分主要是通过模拟随机产生1000条模拟数据，并在中途产生的数据大于900的时候去模拟终止CustomQueue的行为并断言最后的结果和行为。这里需要注意的是ConsumeQueue_TerminatedStatus除了模拟前面中断的行为以外还通过反射确认threadCounter==0确保当前的消费线程都能够得到正确的释放。

1. using NUnit.Framework;
2. using Pangea.Common.Utility.Buffer;
3. using System;
4. using System.Reflection;
5. using System.Threading;
7. namespace ACM.Framework.Test.Modules.Utils
8. {
9.     [TestFixture]
10.     internal class ConsumeQueueTests
11.     {
12.         [Test, Timeout(5000)]
13.         public void ConsumeQueue_IdleProducing()
14.         {
15.             ManualResetEvent mre = new ManualResetEvent(false);
17.             int prevData = -1;
18.             Action<int> consume = data =>
19.             {
20.                 Assert.IsTrue(data - prevData == 1, $"prev-{prevData}, current-{data}");
21.                 prevData = data;
22.             };
24.             Func<bool> func = () => prevData > 900;
26.             Action terminated = () =>
27.             {
28.                 mre.Set();
29.             };
31.             ConsumeQueue<int> queue = new ConsumeQueue<int>(consume, func, terminated);
33.             GenerateIntData(data =>
34.             {
35.                 queue.ProduceItem(data);
36.             }, false);
38.             mre.WaitOne();
39.             int pendingCount = queue.PeedingItemsCount;
40.             var currentState = queue.State;
41.             Assert.IsTrue(currentState == ConsumeQueue<int>.ConsumeState.Terminated, $"current state : {currentState}");
42.             Assert.IsTrue(pendingCount == 0, $"{pendingCount}");
43.         }
45.         [Test, Timeout(5000)]
46.         public void ConsumeQueue_ContinueProducing()
47.         {
48.             ManualResetEvent mre = new ManualResetEvent(false);
50.             int prevData = -1;
51.             Action<int> consume = data =>
52.             {
53.                 Assert.IsTrue(data - prevData == 1, $"prev-{prevData}, current-{data}");
54.                 prevData = data;
55.             };
57.             Func<bool> func = () => prevData > 900;
59.             Action terminated = () =>
60.             {
61.                 mre.Set();
62.             };
64.             ConsumeQueue<int> queue = new ConsumeQueue<int>(consume, func, terminated);
66.             GenerateIntData(data =>
67.             {
68.                 queue.ProduceItem(data);
69.             }, true);
71.             mre.WaitOne();
72.             int pendingCount = queue.PeedingItemsCount;
73.             var currentState = queue.State;
74.             Assert.IsTrue(currentState == ConsumeQueue<int>.ConsumeState.Terminated, $"current state : {currentState}");
75.             Assert.IsTrue(pendingCount == 0, $"{pendingCount}");
76.         }
78.         [Test, Timeout(5000)]
79.         public void ConsumeQueue_TerminatedStatus()
80.         {
81.             ManualResetEvent mre = new ManualResetEvent(false);
83.             int prevData = -1;
84.             Action<int> consume = data =>
85.             {
86.                 Assert.IsTrue(data - prevData == 1, $"prev-{prevData}, current-{data}");
87.                 prevData = data;
88.             };
90.             Func<bool> func = () => prevData > 500;
91.             Action terminated = () => mre.Set();
93.             ConsumeQueue<int> queue = new ConsumeQueue<int>(consume, func, terminated);
95.             GenerateIntData(data =>
96.             {
97.                 queue.ProduceItem(data);
98.                 if(queue.State == ConsumeQueue<int>.ConsumeState.Terminated)
99.                 {
100.                     Assert.IsTrue(queue.PeedingItemsCount == 0);
101.                 }
102.                 else
103.                 {
104.                     Assert.IsTrue(queue.PeedingItemsCount > 0);
105.                 }
106.             }, true);
108.             mre.WaitOne();
110.             Thread.Sleep(1000); // wait one second for waiting consuming thread exit
112.             int pendingCount = queue.PeedingItemsCount;
113.             var currentState = queue.State;
114.             int queueThreadNum = (int)queue.GetType().GetField("_threadCounter", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(queue);
115.             Assert.IsTrue(currentState == ConsumeQueue<int>.ConsumeState.Terminated, $"current state : {currentState}");
116.             Assert.IsTrue(pendingCount == 0, $"{pendingCount}");
117.             Assert.IsTrue(queueThreadNum == 0, $"{queueThreadNum}");
118.         }
121.         private void GenerateIntData(Action<int> intData, bool withIdle)
122.         {
123.             ThreadPool.QueueUserWorkItem(state =>
124.             {
125.                 int target = 1000;
126.                 int index = 0;
127.                 while (index < target)
128.                 {
129.                     intData(index++);
131.                     if (withIdle)
132.                     {
133.                         Thread.Sleep(new Random(Guid.NewGuid().GetHashCode()).Next(1, 5));
134.                     }
135.                 }
136.             });
137.         }
138.     }
139. }

复制代码

来源:https://www.cnblogs.com/seekdream/archive/2023/02/19/17135350.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！