public void OnDequeue() { ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "OnDequeue"); try { IExecutorService exec = this.ExecutorService; while (!exec.WaitForShutdown(_queueTimeout)) { try { T item = _queue.Dequeue(); if (exec.IsShutdown) { break; } if (this.Dequeue != null) { this.Dequeue(item); } } catch (Exception ex) { Log.Exception(PROC, ex); } } } catch (Exception ex) { Log.Exception(PROC, ex); } }
private void OnReceiveMessages() { ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "OnReceiveMessages"); try { while (!this.ExecutorService.WaitForShutdown()) { try { AppNotifyData data = _queue.Dequeue(); if (data != null && _callback != null) { _callback.NotifyData(data); } } catch (Exception ex) { Log.Exception(PROC, ex); } } } catch (Exception ex) { Log.Exception(PROC, ex); } finally { this.Shutdown(); } }
private void OnBroadcastMessages() { ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "OnBroadcastMessages"); try { while (!this.ExecutorService.WaitForShutdown()) { try { AppNotifyData data = _queue.Dequeue(); AppNotifyService.OnNotifyData(data); } catch (Exception ex) { Log.Exception(PROC, ex); } } } catch (Exception ex) { Log.Exception(PROC, ex); _host = null; } finally { this.Stop(); } }
private void DoWork() { ModuleProc PROC = new ModuleProc(DYN_MODULE_NAME, "DoWork"); _doWorkInitialized = InitializeStatus.Completed; int threadId = Thread.CurrentThread.ManagedThreadId; _workerThreadId = threadId; try { while (!this.ExecutorService.WaitForShutdown()) { T item = default(T); try { ThreadExecutorItem <T> executorItem = _queue.Dequeue(); if (this.ExecutorService.IsShutdown) { Log.Info(PROC, string.Format("Shutdown called. Thread : {0:D} is exiting now.", threadId)); break; } if (executorItem == null) { Log.Info(PROC, "Invalid executor item received."); continue; } // actual item Log.DescriptionV(PROC, "Thread : {0:D}, Queue Size : {1:D}", threadId, _queue.QueueCount); item = executorItem.Item; // if any preceeding item there, then wait for it to finish if (executorItem.WaitHandle != null) { // Waiting for previous item to finish WaitHandle wh = executorItem.WaitHandle; Log.Info(PROC, "Waiting for previous item to finish for : " + item.UniqueKey); // if shutdown called? if (this.ExecutorService.WaitForShutdown(wh)) { Log.Info(PROC, string.Format("Shutdown called. Thread : {0:D} is exiting now.", threadId)); break; } // get the signal from the previous item Log.Info(PROC, "Signal got from previous item for : " + item.UniqueKey); } // still have item if (this.ExecutorService.IsShutdown) { Log.Info(PROC, string.Format("Shutdown called. Thread : {0:D} is exiting now.", threadId)); break; } // actual processing and processing completion if (!item.Equals(default(T))) { this.OnProcessItem(item); this.OnProcessItemCompleted(executorItem); if (_checkItemCount && (_itemCount > 0)) { Interlocked.Decrement(ref _itemCount); } } } catch (Exception ex) { Log.Exception(PROC, ex); } } } catch (Exception ex) { Log.Exception(PROC, ex); } finally { Log.Info(PROC, string.Format("Shutdown called. Thread : {0:D} has finished his work.", Thread.CurrentThread.ManagedThreadId)); this.Shutdown(); } }
private void DoWork() { using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "DoWork")) { try { _workerThreadId = Thread.CurrentThread.ManagedThreadId; _threadName = Thread.CurrentThread.Name; if (_threadName.IsEmpty()) { _threadName = "Thread_" + Thread.CurrentThread.ManagedThreadId.ToString(); } method.InfoV("( {0}::DoWork ) {1} started on the thread : {2:D}", _threadName, _uniqueKey, _workerThreadId); while (!_executorService2.WaitForShutdown()) { T item = default(T); try { byte signalItem = _signalQueue.Dequeue(); do { _dataFound = 0; _dataProcessed = 0; if (_executorService2.IsShutdown) { method.InfoV("( {0}::DoWork ) Shutdown called. Thread : {1:D} is exiting now.", _threadName, _workerThreadId); break; } int queuesCount = _dataQueues.Count; Parallel.ForEach <KeyValuePair <string, ConcurrentQueue <ThreadExecutorItem <T> > > >(_dataQueues, (KeyValuePair <string, ConcurrentQueue <ThreadExecutorItem <T> > > p, ParallelLoopState ps) => { int taskId = Task.CurrentId.SafeValue(); int queueCount = 0; if (_executorService2.WaitTokenSource.IsCancellationRequested) { ps.Stop(); } ConcurrentQueue <ThreadExecutorItem <T> > queue = p.Value; queueCount = queue.Count; // data found to process if (queueCount > 0) { try { ThreadExecutorItem <T> executorItem = null; if (queue.TryDequeue(out executorItem)) { _dataFound++; _dataProcessed++; method.DebugV("( {0}::DoWork_PLStart::{1} ) Item Count : {2:D}", _threadName, p.Key, queueCount); if (_executorService2.IsShutdown) { method.InfoV("( {0}::DoWork ) Shutdown called. Thread : {1:D} is exiting now.", _threadName, _workerThreadId); ps.Stop(); } if (executorItem == null) { method.InfoV("( {0}::DoWork ) Shutdown called. Invalid executor item received.", _threadName); return; } // actual item method.DebugV("( {0}::DoWork ) Thread : {1:D}, Queue Size : {2:D}", _threadName, _workerThreadId, queue.Count); item = executorItem.Item; // still have item if (_executorService2.IsShutdown) { method.InfoV("( {0}::DoWork ) Shutdown called. Thread : {1:D} is exiting now.", _threadName, _workerThreadId); ps.Stop(); } // actual processing and processing completion if (!item.Equals(default(T))) { this.OnProcessItem(item); this.OnProcessItemCompleted(executorItem); } } } catch (Exception ex) { method.Exception(ex); } finally { method.DebugV("( {0}::DoWork_PLEnd::{1} ) Item Count : {2:D}", _threadName, p.Key, queueCount); } } else { method.DebugV("( {0}::DoWork_PLStartEnd::{1} ) Item Count : {3:D}", _threadName, p.Key, queueCount); } }); if (_dataProcessed > 0 && ((_itemCount - _dataProcessed) >= 0)) { int newCount = (_itemCount - _dataProcessed); Interlocked.Exchange(ref _itemCount, newCount); method.DebugV("( {0}::DoWork_ItemComplete ) Queue Count : {1:D}, Item Count : {2:D}", _threadName, queuesCount, _itemCount); } if (_executorService2.WaitForShutdown()) { break; } } while (_dataFound > 0); } catch (Exception ex) { method.Exception(ex); } } } catch (Exception ex) { method.Exception(ex); } finally { method.InfoV("( {0}::DoWork ) Shutdown called. Thread : {1:D} has finished its work.", _threadName, _workerThreadId); this.Shutdown(); } } }
private void ListenMonitorQueues() { ModuleProc PROC = new ModuleProc(DYN_MODULE_NAME, "ListenMonitorQueues"); bool canShutdown = true; // Start the queues try { foreach (WorkerInfo workerInfo in _workerInfos.Values) { workerInfo.Processor.ListenAsync(); this.ExecutorService.WaitForShutdown(); } } catch (Exception ex) { Log.Exception(PROC, ex); } // listen for queues try { int length = _queues.Count; // more queues found if (length > 1) { while (!this.ExecutorService.WaitForShutdown()) { for (int i = 0; i < length; i++) { IThreadSafeQueue <QueueMessageWrapper> queue = _queues[i]; bool hasDataInPriorityQueue = false; while (queue.QueueCount > 0) { for (int j = 0; j < i; j++) { // if any items available in the the previous queue if (_queues[j].QueueCount > 0) { hasDataInPriorityQueue = true; break; } if (this.ExecutorService.WaitForShutdown()) { break; } } if (hasDataInPriorityQueue || this.ExecutorService.IsShutdown) { break; } try { _poolExecutor.QueueWorkerItem(queue.Dequeue()); } catch (Exception ex) { Log.Exception(PROC, ex); } if (hasDataInPriorityQueue || this.ExecutorService.WaitForShutdown()) { break; } } if (hasDataInPriorityQueue || this.ExecutorService.WaitForShutdown()) { break; } } } } else // single queue is enough { if (!this.MQUseWorkerThread) { canShutdown = false; } else { IThreadSafeQueue <QueueMessageWrapper> queue = _queues[0]; while (!this.ExecutorService.WaitForShutdown()) { try { _poolExecutor.QueueWorkerItem(queue.Dequeue()); } catch (Exception ex) { Log.Exception(PROC, ex); } } } } } catch (Exception ex) { Log.Exception(PROC, ex); } finally { if (canShutdown) { this.Shutdown(); } } }