public IPEndPoint[] GetListeners()
{
using (ReaderLock rl = new ReaderLock(listenerRWLock)) {
// return a list of endpoints
return(listenerEndPoints.ToArray());
}
}
public IDisposable Read()
{
var locker = new ReaderLock(this);
lock (_lockers) _lockers.Add(locker);
return(locker);
}
public override void ReleaseReadLock() => ReaderLock.RunLocking(() =>
{
int decremented = Interlocked.Decrement(ref readersCount);
if (decremented == 0)
{
GlobalLock.Unlock();
}
});
public override void AcquireReadLock() => ReaderLock.RunLocking(() =>
{
int incremented = Interlocked.Increment(ref readersCount);
if (incremented == 1)
{
GlobalLock.Lock();
}
});
public void ReaderTimedOutIsSetIfTimeoutTimespan()
{
ReaderWriterLock rwLock = new ReaderWriterLock();
Thread t = new Thread(new ParameterizedThreadStart(AcquireWriterLock));
t.Start(rwLock);
Thread.Sleep(20);
using (ReaderLock l = new ReaderLock(rwLock, TimeSpan.FromMilliseconds(10)))
{
Assert.IsTrue(l.TimedOut);
}
Assert.IsFalse(rwLock.IsReaderLockHeld);
}
private void SenderThread()
{
// mark this thread as a background thread
Thread.CurrentThread.IsBackground = true;
Thread.CurrentThread.Name = "Dataset sender thread";
// keep track of client to remove
List <IPEndPoint> removeList = new List <IPEndPoint>();
// enter the send queue lock
Monitor.Enter(sendQueue);
while (true)
{
if (sendQueue.Count == 0)
{
Monitor.Wait(sendQueue);
}
// assume that now there is an entry in the queue
if (sendQueue.Count > 0)
{
// dequeue the entry
SendQueueEntry entry = sendQueue.Dequeue();
// fill up the buffer until we're at our target size
while (sendQueue.Count > 0)
{
SendQueueEntry nextEntry = sendQueue.Peek();
if (entry.length + nextEntry.length <= target_packet_size)
{
// add in this entry
// actually dequeue the entry
sendQueue.Dequeue();
// copy the next entry into our working buffer
Buffer.BlockCopy(nextEntry.buffer, 0, entry.buffer, entry.length, nextEntry.length);
// update the entry length
entry.length += nextEntry.length;
// free the next entry buffer
FreeBuffer(nextEntry.buffer);
}
else
{
// leave the loop, adding the next packet would go over the target size
break;
}
}
// increment the packet count and byte count
packetCount++;
// release the lock
Monitor.Exit(sendQueue);
try {
// acquire a reader lock
using (ReaderLock rl = new ReaderLock(listenerRWLock)) {
// clear the remove list
removeList.Clear();
// iterate through the listeners and send to each of them
foreach (IPEndPoint listener in listenerEndPoints)
{
try {
sender.SendTo(entry.buffer, entry.length, SocketFlags.None, listener);
byteCount += entry.length;
}
catch (Exception) {
// for any client error, add to the remove list
removeList.Add(listener);
}
}
// if there are listeners to remove, acquire a writer lock and remove them
// only wait for 20 milliseconds to get the writer lock to avoid blocking
using (WriterLock wl = rl.UpgradeToWriter(20)) {
foreach (IPEndPoint ep in removeList)
{
listenerEndPoints.Remove(ep);
}
}
doSendDataValues = listenerEndPoints.Count > 0;
}
}
catch (Exception) {
// ignore any exceptions
}
finally {
// re-enter the send queue lock
Monitor.Enter(sendQueue);
}
// free the buffer entry
FreeBuffer(entry.buffer);
}
}
}
public ReadWriteLock(LockRecursionPolicy policy = LockRecursionPolicy.SupportsRecursion)
{
_lock = new ReaderWriterLockSlim(policy);
_rlock = new ReaderLock(this);
_wlock = new WriterLock(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="BlitReaderWriterLock"/> class.
/// </summary>
public BlitReaderWriterLock()
{
_bitIndicator = 0L;
ReadLock = new ReaderLock(this);
WriteLock = new WriterLock(this);
}
public IPEndPoint[] GetListeners() {
using (ReaderLock rl = new ReaderLock(listenerRWLock)) {
// return a list of endpoints
return listenerEndPoints.ToArray();
}
}
private void SenderThread() {
// mark this thread as a background thread
Thread.CurrentThread.IsBackground = true;
Thread.CurrentThread.Name = "Dataset sender thread";
// keep track of client to remove
List<IPEndPoint> removeList = new List<IPEndPoint>();
// enter the send queue lock
Monitor.Enter(sendQueue);
while (true) {
if (sendQueue.Count == 0) {
Monitor.Wait(sendQueue);
}
// assume that now there is an entry in the queue
if (sendQueue.Count > 0) {
// dequeue the entry
SendQueueEntry entry = sendQueue.Dequeue();
// fill up the buffer until we're at our target size
while (sendQueue.Count > 0) {
SendQueueEntry nextEntry = sendQueue.Peek();
if (entry.length + nextEntry.length <= target_packet_size) {
// add in this entry
// actually dequeue the entry
sendQueue.Dequeue();
// copy the next entry into our working buffer
Buffer.BlockCopy(nextEntry.buffer, 0, entry.buffer, entry.length, nextEntry.length);
// update the entry length
entry.length += nextEntry.length;
// free the next entry buffer
FreeBuffer(nextEntry.buffer);
}
else {
// leave the loop, adding the next packet would go over the target size
break;
}
}
// increment the packet count and byte count
packetCount++;
// release the lock
Monitor.Exit(sendQueue);
try {
// acquire a reader lock
using (ReaderLock rl = new ReaderLock(listenerRWLock)) {
// clear the remove list
removeList.Clear();
// iterate through the listeners and send to each of them
foreach (IPEndPoint listener in listenerEndPoints) {
try {
sender.SendTo(entry.buffer, entry.length, SocketFlags.None, listener);
byteCount += entry.length;
}
catch (Exception) {
// for any client error, add to the remove list
removeList.Add(listener);
}
}
// if there are listeners to remove, acquire a writer lock and remove them
// only wait for 20 milliseconds to get the writer lock to avoid blocking
using (WriterLock wl = rl.UpgradeToWriter(20)) {
foreach (IPEndPoint ep in removeList) {
listenerEndPoints.Remove(ep);
}
}
doSendDataValues = listenerEndPoints.Count > 0;
}
}
catch (Exception) {
// ignore any exceptions
}
finally {
// re-enter the send queue lock
Monitor.Enter(sendQueue);
}
// free the buffer entry
FreeBuffer(entry.buffer);
}
}
}
private void ReleaseReaderLock(ReaderLock locker)
{
_lock.ReleaseReaderLock();
lock (_lockers) _lockers.Remove(locker);
}
/// <summary>
/// Creates a new <see cref="Spring.Threading.Locks.ReentrantReadWriteLock"/> with
/// default ordering properties.
/// </summary>
public ReentrantReadWriteLock()
{
_readerLock = new ReaderLock(this);
_writerLock = new WriterLock(this);
}
