private void ReceiverReceived(ILetter receivedLetter) { ResetHeartbeatTimer(); LetterType letterType = receivedLetter.Type; if (letterType == LetterType.Ack) { HandleLetterSent(_queue.Dequeue()); } else { if ((receivedLetter.Options & LetterOptions.Ack) == LetterOptions.Ack) { if (_options.Notification.ReceivedNotifyOnAllAckStates && ((letterType & LetterType.User) == LetterType.User || (letterType & LetterType.Batch) == LetterType.Batch)) { HandleReceivedLetter(receivedLetter, AckState.BeforeAck); } QueueAck(receivedLetter); } else { HandleReceivedLetter(receivedLetter, AckState.NoAck); } } }
public void Enqueue(T obj) { lock (_innerQueue) { if (_innerQueue.Length == _length) { _innerQueue.Dequeue(); } _innerQueue.Enqueue(); } }
private void SpoolUnsentPackets() { EnforceSingleThread(); MemoryStream packet = null; long prevPos = mSendMessageBuffer.Position; while (mPendingSends.Dequeue(out packet)) { mSendMessageBuffer.Position = mSendMessageBuffer.Length; byte[] packetHeader = BitConverter.GetBytes(IPAddress.HostToNetworkOrder((Int32)packet.Length)); mSendMessageBuffer.Write(packetHeader, 0, packetHeader.Length); packet.WriteTo(mSendMessageBuffer); mSendMessageBuffer.Position = prevPos; } if (prevPos > 0 && mSendMessageBuffer.Length > 1000) // XXX this wants to be higher for performance but leave it low for bugchecking { MemoryStream keepMe = new MemoryStream((int)(mSendMessageBuffer.Length - mSendMessageBuffer.Position)); while (mSendMessageBuffer.Position < mSendMessageBuffer.Length) { keepMe.WriteByte((byte)mSendMessageBuffer.ReadByte()); } mSendMessageBuffer.SetLength(0); keepMe.WriteTo(mSendMessageBuffer); mSendMessageBuffer.Position = 0; } }
public static void Main(string[] args) { SNet.Init(); server = new Server(); server.OnReceiveData += OnReceiveData; server.OnClientConnect += OnClientConnect; server.OnClientDisconnect += OnClientDisconnect; server.OnClientTimeout += OnClientTimeout; Thread inputThread = new Thread(() => { HandleConsoleInput(); }); inputThread.Start(); server.Start(8888, 8); while (server.IsRunning()) { while (!consoleInputs.IsEmpty) { string input = consoleInputs.Dequeue(); if (input == "stop") { server.Stop(); } } server.PollEvents(); } server.OnReceiveData -= OnReceiveData; server.OnClientConnect -= OnClientConnect; server.OnClientDisconnect -= OnClientDisconnect; server.OnClientTimeout -= OnClientTimeout; server.Stop(); SNet.Terminate(); }
public void PushToTheLimit() { var queue = new ConcurrentQueue <object>(); var executor = new ParallelWorkExecutor(() => { MemoryLimiter.Wait(); queue.Enqueue(Enumerable.Range(0, 1000).Select(i => Guid.NewGuid()).ToArray()); Thread.Sleep(1); }, () => false, Environment.ProcessorCount); executor.Start(); while (MemoryLimiter.IsEnoughMemory()) { Thread.Sleep(1); } Thread.Sleep(1000); var count = queue.Count; executor.Cancell(false); Assert.AreEqual(count, queue.Count, Environment.ProcessorCount * 2); while (queue.Count > 0) { queue.Dequeue(); } Assert.IsTrue(MemoryLimiter.IsEnoughMemory()); }
private void DequeueSequence() { _output = new List <int> { _queue.Dequeue(), _queue.Dequeue(), _queue.Dequeue(), _queue.Dequeue(), _queue.Dequeue(), _queue.Dequeue(), _queue.Dequeue(), _queue.Dequeue(), _queue.Dequeue(), _queue.Dequeue() }; }
private void Update() { Func <IEnumerator> action; #if !UNITY_EDITOR while (updateQueue.TryDequeue(out action)) { #else while (updateQueue.Count > 0) { action = updateQueue.Dequeue(); #endif action(); } Func <IEnumerator> co; #if !UNITY_EDITOR while (coRoutineQueue.TryDequeue(out co)) { #else while (coRoutineQueue.Count > 0) { co = coRoutineQueue.Dequeue(); #endif StartCoroutine(co()); } }
public LogHandler() { string logDirPath = Application.persistentDataPath + "/logs/"; if (!Directory.Exists(logDirPath)) { Directory.CreateDirectory(logDirPath); } string logFilePath = Path.Combine(logDirPath, DateTime.Now.ToString("MM_dd_hh_mm_ss") + ".log"); new Thread(() => { using (fs = new FileStream(logFilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite)) { sw = new StreamWriter(fs); while (thFlag) { while (logBuffer.Count > 0) { var str = logBuffer.Dequeue(); sw.WriteLine(str); sw.Flush(); } } sw.Close(); } Debug.Log("log thread abort"); }).Start(); Application.logMessageReceivedThreaded += HandleLog; Debug.logger.logHandler = this; Debug.LogFormat("Log path = {0}", logFilePath); }
void Tick() { /*for (int x = 0; x < sizeX; x++) * for (int y = 0; y < sizeY; y++) * for (int z = 0; z < sizeZ; z++) * if (blocks[x, y, z] != null && blocks[x, y, z].UpdateEveryTick) * blocks[x, y, z].Tick(this, 10000000F / (thisFrame - lastFrame));*/ Vector3i a, b; KeyValuePair <Vector3i, Vector3i> kvp; //for (int i = 0; i < blocksToSwap.Count; i++) while (!blocksToSwap.IsEmpty) { //blocksToSwap.TryDequeue(out kvp); kvp = blocksToSwap.Dequeue(); a = kvp.Key; b = kvp.Value; Block tmp = GetBlock(new Vector3i(a.x, a.y, a.z)); SetBlock(a, GetBlock(new Vector3i(b.x, b.y, b.z))); SetBlock(b, tmp); } /*foreach (KeyValuePair<Vector3i, Vector3i> swap in blocksToSwap) * { * Block tmp = GetBlock(new Vector3i(swap.Value.x, swap.Value.y, swap.Value.z)); * SetBlock(swap.Value, GetBlock(new Vector3i(swap.Key.x, swap.Key.y, swap.Key.z))); * SetBlock(swap.Key, tmp); * }*/ }
// --- Event Senders /// <summary> /// From a range of event rows will construct a list of RequestResult objects /// </summary> /// <returns>The results of sending all requests</returns> /// <param name="eventRows">Event rows from the database</param> protected List <RequestResult> SendRequests(List <EventRow> eventRows) { ConcurrentQueue <RequestResult> resultQueue = new ConcurrentQueue <RequestResult> (); int count = 0; if (httpMethod == HttpMethod.GET) { count = HttpGet(eventRows, resultQueue); } else { count = HttpPost(eventRows, resultQueue); } // Wait for the results of each request List <RequestResult> results = new List <RequestResult>(); while (count != 0) { results.Add(resultQueue.Dequeue()); count--; } return(results); }
public void DoActions() { while (actions.Count > 0) { actions.Dequeue()(); } }
void NetworkThread() { while (_running == 1) { var endPoint = new IPEndPoint(IPAddress.Loopback, 4040); RemoteSide remoteSide = null; while (_running == 1 && remoteSide == null) { if ((remoteSide = TryConnect(endPoint)) == null) { Thread.Sleep(1000); } } Interlocked.Exchange(ref _connected, 1); while (_running == 1 && remoteSide.Connected) { StatePortion state; while ((state = remoteSide.ReadMessage()) != null) { _incomingState.Enqueue(state); } Command cmd; while ((cmd = _outgoingCommands.Dequeue()) != null) { remoteSide.WriteMessage(cmd); } Thread.Sleep(1); } Interlocked.Exchange(ref _connected, 0); } ; }
public void Dequeue_returns_None_when_queue_IsEempty() { var q = new ConcurrentQueue<int>(); var p = q.Dequeue(); Assert.IsTrue(p.IsNone); }
public void DoWork() { Pair <Action <string>, string> serviceResult = null; if (mCallbackQueue.Dequeue(out serviceResult)) { serviceResult.First(serviceResult.Second); } }
public void ConcurrentQueue_FunctionsAsNormalQueue_ForSingleThreadedAccess(params int[] numbersToAdd) { // Because we're not doing anything interesting with the queue itself, it seems reasonable to just wrap all of the basic queue API tests into one test // Enqueue foreach (var number in numbersToAdd) { _concurrentQueue.Enqueue(number); } // Peek var head = _concurrentQueue.Peek(); Assert.AreEqual(numbersToAdd.First(), head); // GetEnumerator<T> var index = 0; var genericEnumerator = _concurrentQueue.GetEnumerator(); while (index < numbersToAdd.Length && genericEnumerator.MoveNext()) { Assert.AreEqual(numbersToAdd[index++], genericEnumerator.Current); } Assert.AreEqual(numbersToAdd.Length, index); // GetEnumerator index = 0; var nongenericEnumerator = ((IEnumerable)_concurrentQueue).GetEnumerator(); while (index < numbersToAdd.Length && nongenericEnumerator.MoveNext()) { Assert.AreEqual(numbersToAdd[index++], nongenericEnumerator.Current); } Assert.AreEqual(numbersToAdd.Length, index); // Count Assert.AreEqual(_concurrentQueue.Count, numbersToAdd.Length); // CopyTo var destinationArray = new int[numbersToAdd.Length]; _concurrentQueue.CopyTo(destinationArray, 0); Assert.True(numbersToAdd.SequenceEqual(destinationArray)); // Contains Assert.True(numbersToAdd.All(_concurrentQueue.Contains)); // Dequeue head = _concurrentQueue.Dequeue(); Assert.AreEqual(numbersToAdd.First(), head); Assert.True(_concurrentQueue.SequenceEqual(numbersToAdd.Skip(1))); // Clear _concurrentQueue.Clear(); Assert.AreEqual(0, _concurrentQueue.Count); Assert.False(numbersToAdd.Any(_concurrentQueue.Contains)); }
public void DoWork() { Pair <Action <XmlDocument>, XmlDocument> serviceResult = null; if (mCallbackQueue.Dequeue(out serviceResult)) { serviceResult.First(serviceResult.Second); } }
void Update() { // Action tasks from Android thread while (actions.Count > 0) { Action action = actions.Dequeue(); action(); } }
private void ChannelOnSent(IChannel channel, ILetter letter) { if (letter.Type == LetterType.Batch) { _sentBatch = false; for (int i = 0; i < letter.Parts.Length; i++) { Sent(this, _queue.Dequeue()); } } else { Sent(this, _queue.Dequeue()); } ChannelQueueEmpty(this); TrySendBatch(false); }
public void Dequeue_returns_head_when_queue_is_not_empty() { var q = new ConcurrentQueue<int>(); q.Enqueue(42); var p = q.Dequeue(); Assert.AreEqual(42, p.Value); }
void Update() { if (State == ConnectionState.Connected) { while (queue.Count > 0) { var receivedData = queue.Dequeue(); OnDataReceived(receivedData); } } }
IEnumerator stepMovement(float objectSpeed) { Graph.Node start = movementPath.Dequeue(); Graph.Node end = movementPath.Peek(); actualNodeNumber = end.number; obj.GetComponent <SpriteRenderer>().sortingOrder = start.getZIndex(end); int sign = System.Math.Sign(end.coordinates.x - start.coordinates.x) >= 0? 1: -1; transform.localScale = new Vector3(System.Math.Abs(transform.localScale.x) * sign, transform.localScale.y, transform.localScale.z); yield return(StartCoroutine(MoveObject(transform, start, end, objectSpeed))); }
public void Enqueue(T obj) { q.Enqueue(); lock (this) { if (q.Count > Limit) { q.Dequeue(); } } }
/// <summary> /// Removes and returns the object at the beginning of the System.Collections.Generic.Queue(Of T). while (queue.Count == 0) System.Threading.Monitor.Wait(queue); /// </summary> /// <returns> /// The object that is removed from the beginning of the System.Collections.Generic.Queue(Of T). /// </returns> /// <Exceptions> /// System.InvalidOperationException: The System.Collections.Generic.Queue(Of T) is empty. /// </Exceptions> public T Dequeue() { lock (queue) { while (queue.Count == 0) { // wait for item System.Threading.Monitor.Wait(queue); } return(queue.Dequeue()); } }
public string GetMessage() { if (recvQueue.Count > 0) { string recvMessage = recvQueue.Dequeue(); return(recvMessage); } else { return("none"); } }
private void _sendtoDb() { try { while (_running) { try { TODropCopyDB to = null; #if _CQUEUE lock (_sync) { if (!_queueToDB.TryDequeue(out to)) { lock (_queueToDB) Monitor.Wait(_queueToDB, 50); } if (null != to) { this._processMessage(to); to = null; } } #else lock (_queueToDB) { if (_queueToDB.Count > 0) { to = _queueToDB.Dequeue(); } else { Monitor.Wait(_queueToDB, 5); } } if (null != to) { this._processMessage(to); to = null; } #endif } catch { } } } catch (Exception ex) { logger.Error("Erro ao desenfileirar a mensagem: " + ex.Message, ex); } }
public void PollEvents() { while (raiseConnectionEvent > 0) { if (connected > 0) { OnConnectionSucces?.Invoke(); } else { OnConnectionFailed?.Invoke(); } Interlocked.Exchange(ref raiseConnectionEvent, 0); } if (raiseDisconnectEvent > 0) { OnDisconnect?.Invoke(); Interlocked.Exchange(ref raiseDisconnectEvent, 0); } if (raiseTimeoutEvent > 0) { OnTimeout?.Invoke(); Interlocked.Exchange(ref raiseTimeoutEvent, 0); } while (!pendingReceiveEvents.IsEmpty) { OnReceiveData?.Invoke(pendingReceiveEvents.Dequeue()); } while (!pendingErrorEvents.IsEmpty) { OnError?.Invoke(pendingErrorEvents.Dequeue()); } while (!pendingNetEntityCreatedEvent.IsEmpty) { KeyValuePair <NetEntity, byte[]> pair = pendingNetEntityCreatedEvent.Dequeue(); OnNetEntityCreated?.Invoke(pair.Key, pair.Value); } while (!netEntityReceiveQueue.IsEmpty) { var pair = netEntityReceiveQueue.Dequeue(); OnNetEntityReceiveData?.Invoke(pair.Key, pair.Value); } }
public bool TryDequeue(out string value) { PurgeExpired(); #if NETFX_CORE RequestQueueEntry v; if (q.TryDequeue(out v)) { value = v.Content; return(true); } value = null; return(false); #else if (q.Count == 0) { value = null; return(false); } value = q.Dequeue().Content; return(true); #endif }
private void ClientSend() { while (!stopFlag) { if (sendQueue.Count > 0) { byte[] message = new byte[128]; string data = sendQueue.Dequeue(); message = Encoding.ASCII.GetBytes(data); serverStream.Write(message, 0, message.Length); serverStream.Flush(); } } }
private void LateUpdate() { Func <IEnumerator> action; #if !UNITY_EDITOR while (lateUpdateQueue.TryDequeue(out action)) { #else while (lateUpdateQueue.Count > 0) { action = lateUpdateQueue.Dequeue(); #endif action(); } }
/// <summary> /// Removes a given number of items from the beginning of the queue. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="queue"></param> /// <param name="itemCount"></param> public static void DiscardItems <T>(this ConcurrentQueue <T> queue, int itemCount) { for (int i = 0; i < itemCount; i++) { try { queue.Dequeue(); } catch (InvalidOperationException) { // The queue is already empty. return; } } }
public Letter.Letter Build() { var letter = new Letter.Letter { Type = LetterType.Batch, Options = _batchOptions }; int lettersInBatch = _letters.Count; letter.Parts = new byte[lettersInBatch][]; for (int i = 0; i < lettersInBatch; i++) { letter.Parts[i] = _serializer.Serialize(_letters.Dequeue()); } return(letter); }
public static void ParallelConstructorDemo() { Console.WriteLine("ready press enter."); Console.ReadLine(); var dirCnt = 15; var filesPerDir = 100; var fileCnt = dirCnt * filesPerDir; var r = new Random(); var q = new ConcurrentQueue <string>(); foreach (var name in TestData.MakeNames(2000)) { q.Enqueue(name); } var dirs = TestData.MakeObjectNames(dirCnt).Select(dir => new { name = dir, cnt = r.Next(filesPerDir) }); var tasks = new List <Task>(); var bars = new ConcurrentBag <ProgressBar>(); foreach (var d in dirs) { var files = q.Dequeue(d.cnt).ToArray(); if (files.Length == 0) { continue; } tasks.Add(new Task(() => { var bar = new ProgressBar(files.Count()); bars.Add(bar); bar.Refresh(0, d.name); ProcessFakeFiles(d.name, files, bar); })); } foreach (var t in tasks) { t.Start(); } Task.WaitAll(tasks.ToArray()); Console.WriteLine("done."); }