Nearly all warnings were due to nullability issues, since the concept of nullable reference types did not exist when the DataStream code was originally written. * PubSubClientMessage - Normalize indentation/whitespace - Fix some typos - Address nullability issues to fix build warnings - Modernize code * Compression related files - ZipEntry - ZipFile - ZipInputStream - TarHeader * RemoteMessage - make 'message' nullable to resolve warnings elsewhere (in calling code) * PubSubSingleTagStateEvent.cs * PubSubMessageReactor * PubSubState * SystemHeartbeatPublisher * SystemStatsPublisher * SingleTagData * ManagedTCPMessageHub * PubsubDeserializationController * PublisherCore * InflaterHuffmanTree * AsyncTCPConnection_APM * ThreadSafeQueue * ManagedSubscriber * SubscriberCore * PubSubServerManagedTCPConnection * AsyncTCPConnection_APM * SuperMapStream * MapStream * TradeBarsStream
182 lines
5.1 KiB
C#
182 lines
5.1 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
|
|
namespace BCG
|
|
{
|
|
/// <summary>
|
|
/// Uses locks to provide thread safety. This turns out to be
|
|
/// a problem if there are a lot of threads trying to access
|
|
/// a queue. For this purpose this class will serve as the base
|
|
/// class for later lock free (wait free) implementations
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public class ThreadSafeQueue<T>
|
|
{
|
|
private readonly int _max_size = Int32.MaxValue;
|
|
private Queue<T?> _main_queue = new();
|
|
|
|
private DateTime _last_dequeque_time = DateTime.MinValue;
|
|
private string _queue_name = String.Empty;
|
|
private bool _log_queue_size_warnings = false;
|
|
private int _warning_log_size = Int32.MaxValue;
|
|
private readonly TimeSpan _warning_log_period = TimeSpan.MaxValue, _first_log_period = TimeSpan.FromSeconds(30);
|
|
private DateTime _last_log_time = DateTime.MinValue;
|
|
private readonly DateTime _construction_time = DateTime.Now;
|
|
|
|
public ThreadSafeQueue()
|
|
: this(Int32.MaxValue)
|
|
{ }
|
|
|
|
public ThreadSafeQueue(int max_size)
|
|
: this(max_size, String.Empty, false, Int32.MaxValue, TimeSpan.MaxValue)
|
|
{ }
|
|
|
|
public ThreadSafeQueue(int max_size, string queue_name, bool log_queue_size_warnings, int warning_log_size, TimeSpan warning_log_period)
|
|
{
|
|
_max_size = max_size;
|
|
_queue_name = queue_name;
|
|
_log_queue_size_warnings = log_queue_size_warnings;
|
|
_warning_log_size = warning_log_size;
|
|
_warning_log_period = warning_log_period;
|
|
}
|
|
|
|
public virtual bool enqueue(T? t)
|
|
{
|
|
lock (this)
|
|
{
|
|
int count = getCount();
|
|
_check_size_and_warn(count);
|
|
if (count < _max_size)
|
|
{
|
|
_main_queue.Enqueue(t);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public virtual int enqueue(ICollection<T> list)
|
|
{
|
|
int nElements = 0;
|
|
lock (this)
|
|
{
|
|
foreach (T t in list)
|
|
if (enqueue(t))
|
|
nElements++;
|
|
}
|
|
return nElements;
|
|
}
|
|
|
|
public virtual int getCount()
|
|
{
|
|
int count;
|
|
lock (this) { count = _main_queue.Count; }
|
|
return count;
|
|
}
|
|
|
|
public virtual bool clear_and_enqueue(T t)
|
|
{
|
|
bool rv;
|
|
lock (this)
|
|
{
|
|
_main_queue.Clear();
|
|
rv = enqueue(t);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
public virtual int clear_and_enqueue(ICollection<T> list)
|
|
{
|
|
int rv = 0;
|
|
lock (this)
|
|
{
|
|
_main_queue.Clear();
|
|
rv = enqueue(list);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
public virtual T? dequeue()
|
|
{
|
|
T? rv;
|
|
lock (this)
|
|
{
|
|
if (_main_queue.Count > 0)
|
|
{
|
|
_last_dequeque_time = DateTime.Now;
|
|
rv = _main_queue.Dequeue();
|
|
}
|
|
else
|
|
rv = default;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
public virtual List<T?> dequeueAll()
|
|
{
|
|
var rv = new List<T?>();
|
|
lock (this)
|
|
{
|
|
int sz = getCount();
|
|
for (int i = 0; i < sz; i++)
|
|
rv.Add(dequeue());
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
public virtual bool enqueue_and_crush(T new_elem, Comparison<T?> comp)
|
|
{
|
|
bool rv;
|
|
lock (this)
|
|
{
|
|
Dictionary<int, bool> marked_for_deletion = new Dictionary<int,bool> ();
|
|
var all_elements = dequeueAll();
|
|
for (int i = 0; i < all_elements.Count; i++)
|
|
if (_compare (new_elem, all_elements[i], comp))
|
|
marked_for_deletion.Add (i,true);
|
|
for (int i = 0; i < all_elements.Count; i++)
|
|
if (!marked_for_deletion.ContainsKey(i))
|
|
enqueue(all_elements[i]);
|
|
rv = enqueue(new_elem);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
private static bool _compare(T? t1, T? t2, Comparison<T?> comp)
|
|
{
|
|
if (comp != null)
|
|
return comp (t1, t2) == 0;
|
|
else
|
|
return t1 != null && t1.Equals(t2);
|
|
}
|
|
|
|
public virtual List<T?> dequeueLimited(int max)
|
|
{
|
|
var rv = new List<T?>();
|
|
lock (this)
|
|
{
|
|
int limit = Math.Min (max, _main_queue.Count);
|
|
for (int i = 0; i < limit; i++)
|
|
rv.Add(dequeue());
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
|
|
private void _check_size_and_warn(int count)
|
|
{
|
|
if (_log_queue_size_warnings)
|
|
{
|
|
if (count > _warning_log_size && (DateTime.Now - _last_log_time > _warning_log_period) && (DateTime.Now - _construction_time > _first_log_period))
|
|
{
|
|
_last_log_time = DateTime.Now;
|
|
//mbts.Logger.log(bts.log.Level.Warn, bts.log.Subsystem.gen, String.Format("ThreadSafeQueue size breach queue_name : {0} type : {1} hash : {2} n of elems : {3}", _queue_name, typeof(T), GetHashCode(), count));
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|