C#实现万物皆可排序的队列方法详解 C#实现万物皆可排序的队列方法

需求产品中需要向不同的客户推送数据，原来的实现是每条数据产生后就立即向客户推送数据，走的的是HTTP协议。因为每条数据都比较小，而数据生成的频次也比较高，这就会频繁的建立HTTP连接，而且每次HTTP传输中携带的业务数据都很小，对网络的实际利用率不高。希望能够提高网络的利用率，并降低系统的负载。
分析一个很自然的想法就是将多条数据一起发送，这里有几个关键点：
1、多条数据的聚合逻辑：是攒够几条发送，还是按照时间周期发送。如果是攒够几条发送，在数据比较稀疏或者产生频率不那么稳定的时候，攒够需要的数据条数可能比较困难，这时候还得需要一个过期时间，因为客户可能接受不了太多的延迟。既然不管怎样都需要使用时间进行控制，我这里索性就选择按照时间周期发送了。思路是：自上次发送时间起，经过了某个时长之后，就发送客户在这段时间内产生的所有数据。
【C#实现万物皆可排序的队列方法详解】2、数据到期判断方法：既然选择了按照时间周期发送，那么就必须有办法判断是否到了发送时间。一个很简单的想法就是轮询，把所有客户轮询一遍，看看谁的数据到期了，就发送谁的。这个算法的时间复杂度是O(N)，如果客户比较多，就会消耗过多的时间在这上边。还有一个办法：如果客户按照时间排序好了，那么只需要取时间最早的客户的数据时间判断就好了，满足就发送，一直向后找，直到获取的客户数据时间不符合条件，则退出处理，然后等一会再进行判断处理。这就需要有一个支持排序的数据结构，写入数据时自动排序，这种数据结构的时间复杂度一般可以做到O(log(n))。对于这个数据结构的读写操作原理上就是队列的操作方式，只不过是个可排序的队列。
3、区分客户：不同客户的数据接收地址不同，向具体某个客户发送数据时，应该能比较方便的聚合他的数据，最好是直接就能拿到需要发送的数据。可以使用字典数据结构来满足这个需求，取某个客户数据的时间复杂度可以降低到O(1)。
4、数据的安全性问题：如果程序在数据发送成功之前退出了，未发送的数据怎么办？是还能继续发送，还是就丢掉不管了。如果要在程序重启后恢复未发送成功的数据，则必须将数据同步到别的地方，比如持久化到磁盘。因为我这里的数据安全性要求不高，丢失一些数据也是允许的，所以要发送的数据收到之后放到内存就行了。
实现上文提到可排序的数据结构，可以使用SortedList，键是时间，值是这个时间产生了数据的客户标识列表。不过它的读写操作不是线程安全的，需要自己做同步，这里简单点就使用lock了。
对于不同客户的数据，为了方便获取，使用Dictionary来满足，键是客户的标识，值是累积的未发送客户数据。这个数据读写也不是线程安全的，可以和SortedList的读写放到同一个lock中。
下边是它们的定义：

SortedList> _queue = new SortedList>(); Dictionary> _data = https://www.it610.com/article/new Dictionary>(); readonly object _lock = new object();

插入数据的时候，需要先写入SortedList，然后再写入Dictionary。代码逻辑比较简单，请看：

public void Publish(TKey key, TValue value){DateTime now = DateTime.Now; lock (_lock){if (_queue.TryGetValue(now, out List? keys)){if (!keys!.Contains(key)){keys.Add(key); }}else{_queue.Add(now, new List { key }); }if (_data.TryGetValue(key, out List? values)){values.Add(value); }else{_data.Add(key, new List { value }); }}}

对于消费数据，这里采用拉数据的模式。最开始写的方法逻辑是：读取一条数据，处理它，然后从队列中删除。但是这个逻辑需要对队列进行读写，所以必须加锁。一般处理数据比较耗时，比如这里要通过HTTP发送数据，加锁的话就可能导致写数据到队列时阻塞的时间比较长。所以这里实现的是把可以发送的数据全部提取出来，然后就释放锁，数据的处理放到锁的外部实现，这样队列的读写性能就比较好了。

public List<(TKey key, List value)> Pull(int maxNumberOfMessages){List<(TKey, List)> result = new List<(TKey, List)>(); DateTime now = DateTime.Now; lock (_lock){int messageCount = 0; while (true){if (!_queue.Any()){break; }var first = _queue.First(); var diffMillseconds = now.Subtract(first.Key).TotalMilliseconds; if (diffMillseconds < _valueDequeueMillseconds){break; }var keys = first.Value; foreach (var key in keys){if (_data.TryGetValue(key, out List? keyValues)){result.Add((key, keyValues)); _data.Remove(key); messageCount += keyValues!.Count; }}_queue.RemoveAt(0); if (messageCount >= maxNumberOfMessages){break; }}}return result; }

这段代码比较长一些，我梳理下逻辑：取队列的第一条数据，判断时间是否达到发送周期，未达到则直接退出，方法返回空列表。如果达到发送周期，则取出第一条数据中存储的客户标识，然后根据这些标识获取对应的客户未发送数据，将这些数据按照客户维度添加到返回列表中，将这些客户及其数据从队列中移除，返回有数据的列表。这里还增加了一个拉取数据的条数限制，方便根据业务实际情况进行控制。
再来看一下怎么使用这个队列，这里模拟多个生产者加一个消费者，其实可以任意多个生产者和消费者：

TimeSortedQueue queue = new TimeSortedQueue(3000); List publishTasks = new List(); for (int i = 0; i < 4; i++){var j = i; publishTasks.Add(Task.Factory.StartNew(() =>{int k = 0; while (true){queue.Publish($"key_{k}", $"value_{j}_{k}"); Thread.Sleep(15); k++; }}, TaskCreationOptions.LongRunning)); }Task.Factory.StartNew(() =>{while (true){var list = queue.Pull(100); if (list.Count <= 0){Thread.Sleep(100); continue; }foreach (var item in list){Console.WriteLine($"{DateTime.Now.ToString("mmss.fff")}:{item.key}, {string.Join(",", item.value)}"); }}}, TaskCreationOptions.LongRunning); Task.WaitAll(publishTasks.ToArray());

以上就是针对这个特定需求实现的一个按照时间进行排序的队列。
万物皆可排序的队列
我们很容易想到，既然可以按照时间排序，那么按照别的数据类型排序也是可以的。这个数据结构可以应用的场景很多，比如按照权重排序的队列、按照优先级排序的队列、按照年龄排序的队列、按照银行存款排序的队列，等等。这就是一个万物皆可排序的队列。
我这里把主要代码贴出来（完整代码和示例请看文末）：

public class SortedQueuewhere TSortKey : notnull, IComparablewhere TKey : notnullwhere TValue : notnull{Dictionary> _data = https://www.it610.com/article/new Dictionary>(); SortedList> _queue = new SortedList>(); readonly object _lock = new object(); /// /// Create a new instance of SortedQueue/// public SortedQueue(int maxNumberOfMessageConsumedOnce){}/// /// Publish a message to queue/// /// The key in the queue for sorting. Different messages can use the same key./// The message key./// The message value.public void Publish(TSortKey sortKey, TKey key, TValue value){lock (_lock){if (_queue.TryGetValue(sortKey, out List? keys)){keys.Add(key); }else{_queue.Add(sortKey, new List { key }); }if (_data.TryGetValue(key, out List? values)){values.Add(value); }else{_data.Add(key, new List { value }); }}}/// /// Pull a batch of messages./// /// The maximum number of pull messages./// public List<(TKey Key, List Value)> Pull(int maxNumberOfMessages){List<(TKey, List)> result = new List<(TKey, List)>(); lock (_lock){int messageCount = 0; while (true){if (!_queue.Any()){break; }var keys = _queue.First().Value; foreach (var key in keys){if (_data.TryGetValue(key, out List? keyValues)){result.Add((key, keyValues)); _data.Remove(key); messageCount += keyValues!.Count; }}_queue.RemoveAt(0); if (messageCount >= maxNumberOfMessages){break; }}}return result; }}

代码逻辑还是比较简单的，就不罗嗦了，如有问题欢迎留言交流。
再说数据安全因为在这个实现中所有待处理的数据都在内存中，丢失数据会带来一定的风险，因为我这个程序前边还有一个队列，即使程序崩溃了，也只损失没处理的一小部分数据，业务上可以接受，所以这样做没有问题。如果你对这个程序感兴趣，需要慎重考虑你的应用场景。
来看看数据丢失可能发生的两种情况：
一是数据还在队列中时程序重启了：对于这种情况，前文提到将数据同步到其它地方，比如写入Redis、写入数据库、写入磁盘等等。不过因为网络IO、磁盘IO较慢，这往往会带来吞吐量的大幅下降，想要保证一定的吞吐量，还得引入一些分片机制，又因为分布式的不可靠，可能还得增加一些容错容灾机制，比较复杂，可以参考Kafka。
二是数据处理的时候失败了：对于这种情况，可以让程序重试；但是如果异常导致程序崩溃了，数据已经从内存或者其它存储中移除了，数据还是会发生丢失。这时候可以采用一个ACK机制，处理成功后向队列发送一个ACK，携带已经处理的数据标识，队列根据标识删除数据。否则消费者还能消费到这些数据。
这些问题并不一定要完全解决，还是得看业务场景，有可能你把数据持久化到Redis就够了，或者你也不用引入ACK机制，记录下处理到哪一条了就行了。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。