// Tests that a listener is only invoked by a single thread at any time even if multiple threads are
// invoking the wrapper concurrently.
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void concurrentExecution() throws InterruptedException
public virtual void concurrentExecution()
{
int nThreads = Runtime.Runtime.availableProcessors();
int resultsPerThread = 10;
ConcurrentLinkedQueue <string> errors = new ConcurrentLinkedQueue <string>();
System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
int expectedResultCount = nThreads * resultsPerThread;
Listener listener = new Listener(errors, latch);
System.Action <CalculationResults> wrapper = new ListenerWrapper(listener, expectedResultCount, ImmutableList.of(), ImmutableList.of());
ExecutorService executor = Executors.newFixedThreadPool(nThreads);
CalculationResult result = CalculationResult.of(0, 0, Result.failure(FailureReason.ERROR, "foo"));
CalculationTarget target = new CalculationTargetAnonymousInnerClass(this);
CalculationResults results = CalculationResults.of(target, ImmutableList.of(result));
IntStream.range(0, expectedResultCount).forEach(i => executor.submit(() => wrapper(results)));
latch.await();
executor.shutdown();
if (!errors.Empty)
{
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
string allErrors = errors.collect(joining("\n"));
fail(allErrors);
}
}
//JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the Java 'super' constraint:
//ORIGINAL LINE: public void forEachRemaining(java.util.function.Consumer<? base E> action)
public void forEachRemaining <T1>(Consumer <T1> action)
{
Node <E> p;
if (action == null)
{
throw new NullPointerException();
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ConcurrentLinkedQueue<E> q = this.queue;
ConcurrentLinkedQueue <E> q = this.Queue;
if (!Exhausted && ((p = Current) != null || (p = q.First()) != null))
{
Exhausted = true;
do
{
E e = p.Item;
if (p == (p = p.Next))
{
p = q.First();
}
if (e != null)
{
action.Accept(e);
}
} while (p != null);
}
}
//JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the Java 'super' constraint:
//ORIGINAL LINE: public boolean tryAdvance(java.util.function.Consumer<? base E> action)
public bool tryAdvance <T1>(Consumer <T1> action)
{
Node <E> p;
if (action == null)
{
throw new NullPointerException();
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ConcurrentLinkedQueue<E> q = this.queue;
ConcurrentLinkedQueue <E> q = this.Queue;
if (!Exhausted && ((p = Current) != null || (p = q.First()) != null))
{
E e;
do
{
e = p.Item;
if (p == (p = p.Next))
{
p = q.First();
}
} while (e == null && p != null);
if ((Current = p) == null)
{
Exhausted = true;
}
if (e != null)
{
action.Accept(e);
return(true);
}
}
return(false);
}
private static void addListToHead(PspGeList list)
{
lock (drawListQueue)
{
// The ConcurrentLinkedQueue type doesn't allow adding
// objects directly at the head of the queue.
// This function creates a new array using the given list as it's head
// and constructs a new ConcurrentLinkedQueue based on it.
// The actual drawListQueue is then replaced by this new one.
int arraySize = drawListQueue.size();
if (arraySize > 0)
{
PspGeList[] array = drawListQueue.toArray(new PspGeList[arraySize]);
ConcurrentLinkedQueue <PspGeList> newQueue = new ConcurrentLinkedQueue <PspGeList>();
PspGeList[] newArray = new PspGeList[arraySize + 1];
newArray[0] = list;
for (int i = 0; i < arraySize; i++)
{
newArray[i + 1] = array[i];
newQueue.add(newArray[i]);
}
drawListQueue = newQueue;
}
else
{ // If the queue is empty.
drawListQueue.add(list);
}
}
}
public UDPOutput(ConcurrentLinkedQueue inputQueue, Selector selector, LocalVPNService vpnService)
{
this.inputQueue = inputQueue;
this.selector = selector;
this.vpnService = vpnService;
this.channelCache = new LRUChannelCache(this, MAX_CACHE_SIZE);
}
public Task<bool> WaitAsync(Int32 duration, CancellationToken token)
{
VerboseLog("{0:000}|{1}|async wait requested", Thread.CurrentThread.Id, _id);
CheckDisposed();
token.ThrowIfCancellationRequested();
if (_sem.TryAcquire())
{
VerboseLog("{0:000}|{1}|async wait immediate success", Thread.CurrentThread.Id,_id);
return Task.FromResult(true);
}
if(duration == 0)
return Task.FromResult(false);
if (_asyncWaiters == null)
{
lock (this)
{
if (_asyncWaiters == null)
_asyncWaiters = new ConcurrentLinkedQueue<AsyncWaiter>();
}
}
AsyncWaiter waiter = new AsyncWaiter();
TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
waiter.Task = task;
if (duration != -1)
{
waiter.CancelDelay = new CancellationTokenSource();
waiter.Delay = Task.Delay(duration, waiter.CancelDelay.Token);
waiter.Delay.ContinueWith(new ActionContinuation(() => TimeoutAsync(waiter)));
}
if (token != CancellationToken.None)
{
waiter.CancelRegistration = token.Register(() => CancelAsync(waiter));
}
_asyncWaiters.Add(waiter);
VerboseLog("{0:000}|{1}|async wait enqued: {2:X}; {3}", Thread.CurrentThread.Id, _id, waiter.GetHashCode(), waiter.Task.Task.Id);
if (_wasDisposed || token.IsCancellationRequested || waiter.Delay != null && waiter.Delay.IsCompleted)
{
// Mitigate the above race where a finishing condition occured
// before where able to add our waiter to the waiters list.
if (_asyncWaiters.Remove(waiter))
{
CleanUpWaiter(waiter);
}
}
return task.Task;
}
public void ShouldEnqueueAndDequeue ()
{
ConcurrentLinkedQueue<int> pool = new ConcurrentLinkedQueue<int>();
pool.Enqueue (1);
Assert.AreEqual (1, pool.Dequeue ());
}
public TCPOutput(ConcurrentLinkedQueue inputQueue, ConcurrentLinkedQueue outputQueue,
Selector selector, LocalVPNService vpnService)
{
this.inputQueue = inputQueue;
this.outputQueue = outputQueue;
this.selector = selector;
this.vpnService = vpnService;
}
public void ShouldEnqueueAndDequeue()
{
ConcurrentLinkedQueue <int> pool = new ConcurrentLinkedQueue <int>();
pool.Enqueue(1);
Assert.AreEqual(1, pool.Dequeue());
}
private void Cleanup()
{
deviceToNetworkTCPQueue = null;
deviceToNetworkUDPQueue = null;
networkToDeviceQueue = null;
ByteBufferPool.Clear();
CloseResources(udpSelector, tcpSelector, vpnInterface);
}
public VPNRunnable(FileDescriptor vpnFileDescriptor,
ConcurrentLinkedQueue deviceToNetworkUDPQueue,
ConcurrentLinkedQueue deviceToNetworkTCPQueue,
ConcurrentLinkedQueue networkToDeviceQueue)
{
this.vpnFileDescriptor = vpnFileDescriptor;
this.deviceToNetworkUDPQueue = deviceToNetworkUDPQueue;
this.deviceToNetworkTCPQueue = deviceToNetworkTCPQueue;
this.networkToDeviceQueue = networkToDeviceQueue;
}
/**
* Create a new scheduled task service. The thread pool size is from the WorldWind configuration file property
* {@link AVKey#TASK_POOL_SIZE}.
*/
public BasicScheduledTaskService()
{
Integer poolSize = Configuration.getIntegerValue(AVKey.TASK_POOL_SIZE, DEFAULT_POOL_SIZE);
// this.executor runs the tasks, each in their own thread
this.executor = new ScheduledTaskExecutor(poolSize);
// this.activeTasks holds the list of currently executing tasks
this.activeTasks = new ConcurrentLinkedQueue <Runnable>();
}
public void ShouldEnqueueAndDequeueMultiple ()
{
ConcurrentLinkedQueue<int> pool = new ConcurrentLinkedQueue<int>();
for (int i = 1; i <= 10; i++) {
pool.Enqueue (i);
}
for (int i = 1; i <= 10; i++) {
Assert.AreEqual (i, pool.Dequeue ());
}
}
public RMCommunicator(ClientService clientService, AppContext context)
: base("RMCommunicator")
{
//millis
// Has a signal (SIGTERM etc) been issued?
this.clientService = clientService;
this.context = context;
this.eventHandler = context.GetEventHandler();
this.applicationId = context.GetApplicationID();
this.stopped = new AtomicBoolean(false);
this.heartbeatCallbacks = new ConcurrentLinkedQueue <Runnable>();
this.schedulerResourceTypes = EnumSet.Of(YarnServiceProtos.SchedulerResourceTypes
.Memory);
}
public void ShouldEnqueueAndDequeueMultiple()
{
ConcurrentLinkedQueue <int> pool = new ConcurrentLinkedQueue <int>();
for (int i = 1; i <= 10; i++)
{
pool.Enqueue(i);
}
for (int i = 1; i <= 10; i++)
{
Assert.AreEqual(i, pool.Dequeue());
}
}
public void Add(TCompletion continuation)
{
if (single == null)
{
single = continuation;
return;
}
if (completed == null)
{
completed = new ConcurrentLinkedQueue <TCompletion>();
}
completed.Add(continuation);
}
/// <summary>Return a buffer into the pool.</summary>
/// <remarks>
/// Return a buffer into the pool. After being returned,
/// the buffer may be recycled, so the user must not
/// continue to use it in any way.
/// </remarks>
/// <param name="buf">the buffer to return</param>
public virtual void ReturnBuffer(ByteBuffer buf)
{
buf.Clear();
// reset mark, limit, etc
int size = buf.Capacity();
Queue <WeakReference <ByteBuffer> > list = buffersBySize[size];
if (list == null)
{
list = new ConcurrentLinkedQueue <WeakReference <ByteBuffer> >();
Queue <WeakReference <ByteBuffer> > prev = buffersBySize.PutIfAbsent(size, list);
// someone else put a queue in the map before we did
if (prev != null)
{
list = prev;
}
}
list.AddItem(new WeakReference <ByteBuffer>(buf));
}
private static void deactivate()
{
drawListQueue = null;
if (setLogLevelThread != null)
{
setLogLevelThread.exit();
setLogLevelThread = null;
}
CoreThread.exit();
if (rendererThreads != null)
{
for (int i = 0; i < rendererThreads.Length; i++)
{
rendererThreads[i].exit();
}
rendererThreads = null;
}
}
public override void OnCreate()
{
base.OnCreate();
isRunning = true;
SetupVPN();
if (vpnInterface == null)
{
Log.Error(TAG, "Vpn Interface is null. Something when wrong.");
StopSelf();
return;
}
try
{
udpSelector = Selector.Open();
tcpSelector = Selector.Open();
deviceToNetworkUDPQueue = new ConcurrentLinkedQueue();
deviceToNetworkTCPQueue = new ConcurrentLinkedQueue();
networkToDeviceQueue = new ConcurrentLinkedQueue();
executorService = Executors.NewFixedThreadPool(5);
executorService.Submit(new UDPInput(networkToDeviceQueue, udpSelector));
executorService.Submit(new UDPOutput(deviceToNetworkUDPQueue, udpSelector, this));
executorService.Submit(new TCPInput(networkToDeviceQueue, tcpSelector));
executorService.Submit(new TCPOutput(deviceToNetworkTCPQueue, networkToDeviceQueue, tcpSelector, this));
executorService.Submit(new VPNRunnable(vpnInterface.FileDescriptor, deviceToNetworkUDPQueue, deviceToNetworkTCPQueue, networkToDeviceQueue));
LocalBroadcastManager.GetInstance(this).SendBroadcast(new Intent(BROADCAST_VPN_STATE).PutExtra("running", true));
Log.Info(TAG, "Started");
}
catch (IOException e)
{
// TODO: Here and elsewhere, we should explicitly notify the user of any errors
// and suggest that they stop the service, since we can't do it ourselves
Log.Error(TAG, "Error starting service", e);
Cleanup();
}
}
public override void start()
{
Console.WriteLine(string.Format("Starting {0}", Name));
waitingForSync = false;
syncDone = false;
signalCallbacks = new Dictionary <int, SceKernelCallbackInfo>();
finishCallbacks = new Dictionary <int, SceKernelCallbackInfo>();
listFreeQueue = new ConcurrentLinkedQueue <PspGeList>();
allGeLists = new PspGeList[NUMBER_GE_LISTS];
for (int i = 0; i < NUMBER_GE_LISTS; i++)
{
allGeLists[i] = new PspGeList(i);
listFreeQueue.add(allGeLists[i]);
}
deferredThreadWakeupQueue = new ConcurrentLinkedQueue <int>();
eDRAMMemoryWidth = 1024;
base.start();
}
public Spliterator <E> TrySplit()
{
Node <E> p;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ConcurrentLinkedQueue<E> q = this.queue;
ConcurrentLinkedQueue <E> q = this.Queue;
int b = Batch;
int n = (b <= 0) ? 1 : (b >= MAX_BATCH) ? MAX_BATCH : b + 1;
if (!Exhausted && ((p = Current) != null || (p = q.First()) != null) && p.Next != null)
{
Object[] a = new Object[n];
int i = 0;
do
{
if ((a[i] = p.Item) != null)
{
++i;
}
if (p == (p = p.Next))
{
p = q.First();
}
} while (p != null && i < n);
if ((Current = p) == null)
{
Exhausted = true;
}
if (i > 0)
{
Batch = i;
return(Spliterators.Spliterator(a, 0, i, java.util.Spliterator_Fields.ORDERED | java.util.Spliterator_Fields.NONNULL | java.util.Spliterator_Fields.CONCURRENT));
}
}
return(null);
}
/// <summary>
/// Send update notification over data channel of RTMP connection
/// </summary>
private void SendUpdates()
{
int currentVersion = _version.Value;
bool persist = this.IsPersistentObject;
//Get read-only version of events
ConcurrentLinkedQueue <ISharedObjectEvent> events = new ConcurrentLinkedQueue <ISharedObjectEvent>(_ownerMessage.Events);
//clear out previous events
_ownerMessage.Events.Clear();
if (events.Count != 0)
{
//Send update to "owner" of this update request
if (_source != null)
{
RtmpConnection connection = _source as RtmpConnection;
// Only send updates when issued through RTMP request
RtmpChannel channel = connection.GetChannel((byte)3);
// Send update to "owner" of this update request
SharedObjectMessage syncOwner;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
{
syncOwner = new SharedObjectMessage(null, _name, currentVersion, persist);
}
else
{
syncOwner = new FlexSharedObjectMessage(null, _name, currentVersion, persist);
}
syncOwner.AddEvents(events);
if (channel != null)
{
channel.Write(syncOwner);
}
else
{
log.Warn(__Res.GetString(__Res.Channel_NotFound));
}
}
}
//Clear owner events
events.Clear();
//Get read-only version of sync events
events.AddRange(_syncEvents);
//Clear out previous events
_syncEvents.Clear();
if (events.Count != 0)
{
// Synchronize updates with all registered clients of this shared
foreach (IEventListener listener in _listeners)
{
if (listener == _source)
{
// Don't re-send update to active client
continue;
}
if (!(listener is RtmpConnection))
{
log.Warn(__Res.GetString(__Res.SharedObject_SyncConnError));
continue;
}
// Create a new sync message for every client to avoid
// concurrent access through multiple threads
// TODO: perhaps we could cache the generated message
RtmpConnection connection = listener as RtmpConnection;
SharedObjectMessage syncMessage;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
{
syncMessage = new SharedObjectMessage(null, _name, currentVersion, persist);
}
else
{
syncMessage = new FlexSharedObjectMessage(null, _name, currentVersion, persist);
}
syncMessage.AddEvents(events);
RtmpChannel channel = connection.GetChannel((byte)3);
log.Debug(__Res.GetString(__Res.SharedObject_Sync, channel));
channel.Write(syncMessage);
}
}
}
public ProtobufParser()
{
_conMessages = new ConcurrentQueue <PacketTuple <IMessage> >();
_messages = new ConcurrentLinkedQueue <PacketTuple <IMessage> >();
}
public TCPInput(ConcurrentLinkedQueue outputQueue, Selector selector)
{
this.outputQueue = outputQueue;
this.selector = selector;
}
public Task <bool> WaitAsync(Int32 duration, CancellationToken token)
{
VerboseLog("{0:000}|{1}|async wait requested", Thread.CurrentThread.Id, _id);
CheckDisposed();
token.ThrowIfCancellationRequested();
if (_sem.TryAcquire())
{
VerboseLog("{0:000}|{1}|async wait immediate success", Thread.CurrentThread.Id, _id);
return(Task.FromResult(true));
}
if (duration == 0)
{
return(Task.FromResult(false));
}
if (_asyncWaiters == null)
{
lock (this)
{
if (_asyncWaiters == null)
{
_asyncWaiters = new ConcurrentLinkedQueue <AsyncWaiter>();
}
}
}
AsyncWaiter waiter = new AsyncWaiter();
TaskCompletionSource <bool> task = new TaskCompletionSource <bool>();
waiter.Task = task;
if (duration != -1)
{
waiter.CancelDelay = new CancellationTokenSource();
waiter.Delay = Task.Delay(duration, waiter.CancelDelay.Token);
waiter.Delay.ContinueWith(new ActionContinuation(() => TimeoutAsync(waiter)));
}
if (token != CancellationToken.None)
{
waiter.CancelRegistration = token.Register(() => CancelAsync(waiter));
}
_asyncWaiters.Add(waiter);
VerboseLog("{0:000}|{1}|async wait enqued: {2:X}; {3}", Thread.CurrentThread.Id, _id, waiter.GetHashCode(), waiter.Task.Task.Id);
if (_wasDisposed || token.IsCancellationRequested || waiter.Delay != null && waiter.Delay.IsCompleted)
{
// Mitigate the above race where a finishing condition occured
// before where able to add our waiter to the waiters list.
if (_asyncWaiters.Remove(waiter))
{
CleanUpWaiter(waiter);
}
}
return(task.Task);
}
private static void activate()
{
drawListQueue = new ConcurrentLinkedQueue <PspGeList>();
setLogLevelThread = new SetLogLevelThread();
setLogLevelThread.setName("ExternelGE Set Log Level Thread");
setLogLevelThread.setDaemon(true);
setLogLevelThread.Start();
if (numberRendererThread > 0)
{
rendererThreads = new RendererThread[numberRendererThread];
int[] lineMasks = new int[numberRendererThread];
switch (numberRendererThread)
{
case 1:
lineMasks[0] = unchecked ((int)0xFFFFFFFF);
break;
case 2:
lineMasks[0] = unchecked ((int)0xFF00FF00);
lineMasks[1] = 0x00FF00FF;
break;
case 3:
lineMasks[0] = unchecked ((int)0xF801F001);
lineMasks[1] = 0x07C00F80;
lineMasks[3] = 0x003E007E;
break;
case 4:
case 5:
case 6:
case 7:
lineMasks[0] = unchecked ((int)0xFF000000);
lineMasks[1] = 0x00FF0000;
lineMasks[2] = 0x0000FF00;
lineMasks[3] = 0x000000FF;
break;
case 8:
default:
lineMasks[0] = unchecked ((int)0xC000C000);
lineMasks[1] = 0x30003000;
lineMasks[2] = 0x0C000C00;
lineMasks[3] = 0x03000300;
lineMasks[4] = 0x00C000C0;
lineMasks[5] = 0x00300030;
lineMasks[6] = 0x000C000C;
lineMasks[7] = 0x00030003;
break;
}
int allLineMasks = 0;
for (int i = 0; i < rendererThreads.Length; i++)
{
int lineMask = lineMasks[i];
rendererThreads[i] = new RendererThread(lineMask);
rendererThreads[i].Name = string.Format("Renderer Thread #{0:D}", i);
rendererThreads[i].Start();
if ((allLineMasks & lineMask) != 0)
{
Console.WriteLine(string.Format("Incorrect line masks for the renderer threads (number={0:D})", numberRendererThread));
}
allLineMasks |= lineMask;
}
if (allLineMasks != unchecked ((int)0xFFFFFFFF))
{
Console.WriteLine(string.Format("Incorrect line masks for the renderer threads (number={0:D})", numberRendererThread));
}
rendererThreadsDone = new Semaphore(0);
}
NativeUtils.RendererAsyncRendering = numberRendererThread > 0;
ScreenScale = sceDisplay.getResizedWidthPow2(1);
lock (screenScaleLock)
{
NativeUtils.ScreenScale = ScreenScale;
}
// Used by HD Remaster
int maxTextureSize = Settings.Instance.readInt("maxTextureSize", 512);
int maxTextureSizeLog2 = 31 - Integer.numberOfLeadingZeros(maxTextureSize);
NativeUtils.MaxTextureSizeLog2 = maxTextureSizeLog2;
bool doubleTexture2DCoords = Settings.Instance.readBool("doubleTexture2DCoords");
NativeUtils.DoubleTexture2DCoords = doubleTexture2DCoords;
}
internal bool Exhausted; // true when no more nodes
internal CLQSpliterator(ConcurrentLinkedQueue <E> queue)
{
this.Queue = queue;
}
internal Itr(ConcurrentLinkedQueue <E> outerInstance)
{
this.OuterInstance = outerInstance;
Advance();
}
public static void clear(this ConcurrentLinkedQueue queue)
{
queue.Clear();
}
public static bool add(this ConcurrentLinkedQueue queue, Java.Lang.Object value)
{
return(queue.Add(value));
}
public void Initialize()
{
socketStateQueue = new ConcurrentLinkedQueue <SocketConnectState>();
receiverQueue = new ConcurrentLinkedQueue <IReceiver>();
senderQueue = new ConcurrentLinkedQueue <IBaseMessage>();
}
/// <summary>
/// Send update notification over data channel of RTMP connection
/// </summary>
private void SendUpdates()
{
int currentVersion = _version.Value;
bool persist = this.IsPersistentObject;
//Get read-only version of events
ConcurrentLinkedQueue<ISharedObjectEvent> events = new ConcurrentLinkedQueue<ISharedObjectEvent>(_ownerMessage.Events);
//clear out previous events
_ownerMessage.Events.Clear();
if (events.Count != 0)
{
//Send update to "owner" of this update request
if(_source != null)
{
RtmpConnection connection = _source as RtmpConnection;
// Only send updates when issued through RTMP request
RtmpChannel channel = connection.GetChannel((byte)3);
// Send update to "owner" of this update request
SharedObjectMessage syncOwner;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
syncOwner = new SharedObjectMessage(null, _name, currentVersion, persist);
else
syncOwner = new FlexSharedObjectMessage(null, _name, currentVersion, persist);
syncOwner.AddEvents(events);
if(channel != null)
{
channel.Write(syncOwner);
}
else
{
log.Warn(__Res.GetString(__Res.Channel_NotFound));
}
}
}
//Clear owner events
events.Clear();
//Get read-only version of sync events
events.AddRange(_syncEvents);
//Clear out previous events
_syncEvents.Clear();
if (events.Count != 0)
{
// Synchronize updates with all registered clients of this shared
foreach(IEventListener listener in _listeners)
{
if(listener == _source)
{
// Don't re-send update to active client
continue;
}
if(!(listener is RtmpConnection))
{
log.Warn(__Res.GetString(__Res.SharedObject_SyncConnError));
continue;
}
// Create a new sync message for every client to avoid
// concurrent access through multiple threads
// TODO: perhaps we could cache the generated message
RtmpConnection connection = listener as RtmpConnection;
SharedObjectMessage syncMessage;
if (connection.ObjectEncoding == ObjectEncoding.AMF0)
syncMessage = new SharedObjectMessage(null, _name, currentVersion, persist);
else
syncMessage = new FlexSharedObjectMessage(null, _name, currentVersion, persist);
syncMessage.AddEvents(events);
RtmpChannel channel = connection.GetChannel((byte)3);
log.Debug(__Res.GetString(__Res.SharedObject_Sync, channel));
channel.Write(syncMessage);
}
}
}
public ConcurrentLinkedQueueRecentBuffer(int bitSize)
{
_maxSize = 1 << bitSize;
_queue = new ConcurrentLinkedQueue <T>();
_size = new AtomicInteger(0);
}
