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