Files
spark/src/DataStreamSuite/PubSub/Misc/ThreadSafeQueue.cs
T
John Colvin 7ebafd8246 cleanup: Fix numerous build warnings in DataStreamSuite
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
2024-11-25 15:26:57 +00:00

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));
}
}
}
}
}