public void EnqueueDequeueStop_1000000() { WorkingThread <object> aWorkingThread = new WorkingThread <object>(); AutoResetEvent aQueueCompleted = new AutoResetEvent(false); List <string> aReceivedMessages = new List <string>(); Action <object> aProcessingCallback = x => { aReceivedMessages.Add((string)x); if (aReceivedMessages.Count == 1000000) { aQueueCompleted.Set(); } }; aWorkingThread.RegisterMessageHandler(aProcessingCallback); Stopwatch aStopWatch = new Stopwatch(); aStopWatch.Start(); for (int i = 0; i < 1000000; ++i) { aWorkingThread.EnqueueMessage("a"); } aQueueCompleted.WaitOne(); aStopWatch.Stop(); Console.WriteLine("Elapsed time: {0}", aStopWatch.Elapsed); aWorkingThread.UnregisterMessageHandler(); }
public void EnqueueDequeueStop() { WorkingThread <object> aWorkingThread = new WorkingThread <object>(); AutoResetEvent aQueueCompleted = new AutoResetEvent(false); List <string> aReceivedMessages = new List <string>(); Action <object> aProcessingCallback = x => { aReceivedMessages.Add((string)x); if (aReceivedMessages.Count == 3) { aQueueCompleted.Set(); } }; aWorkingThread.RegisterMessageHandler(aProcessingCallback); aWorkingThread.EnqueueMessage("Message1"); aWorkingThread.EnqueueMessage("Message2"); aWorkingThread.EnqueueMessage("Message3"); aQueueCompleted.WaitOne(); aWorkingThread.UnregisterMessageHandler(); Assert.AreEqual("Message1", aReceivedMessages[0]); Assert.AreEqual("Message2", aReceivedMessages[1]); Assert.AreEqual("Message3", aReceivedMessages[2]); }
public void Run() { WorkingThread.Enqueue("Cluster Run", () => { _ToStart.Enabled = true; }); }
public void Deactivate() { WorkingThread.Enqueue("Cluster Deactivate", () => { Logger.Trace <Cluster>("Deactivate"); if (_State.LocalNode.State == NodeState.NoActive) { Logger.Info <Cluster>(String.Format(Resources.AlreadyDeactivate, _State.LocalNode.StateBegin)); return; } if (_State.RemoteNode.State == NodeState.NoValid) { throw new InvalidOperationException(Resources.DeactivateValidRemoteNodeError); } if ((NumValidAdapters(_State.RemoteNode.ValidAdaptersMask) < NumValidAdapters(_State.LocalNode.ValidAdaptersMask))) { throw new InvalidOperationException(Resources.DeactivateNumAdaptersError); } if (_State.LocalNode.State == NodeState.Active) { DeleteVirtualAddresses(false); } _State.LocalNode.SetState(NodeState.NoActive, Resources.LocalDeactivateAsk); }); }
void Start() { if (thread == null) { thread = new WorkingThread(); } }
void Start() { DontDestroyOnLoad(gameObject); if (thread == null) { thread = new WorkingThread(); } }
public void Activate() { WorkingThread.Enqueue("Cluster Activate", () => { Logger.Trace <Cluster>("Activate"); InternalActivate(); }); // Todo Sincronizar con Activacion Efectiva }
// add a working thread to the list of active threads private WorkingThread AddThread() { WorkingThread thread = new WorkingThread(); threads.Add(thread); thread.Initialize(); activeThreads = threads.Count; return thread; }
public void RequestReadID() { if (WorkingThread != null) { WorkingThread.RequestReadID(); } else { IdReaderHW = null; } }
public void RequestReadSN() { if (WorkingThread != null) { WorkingThread.RequestReadSN(); } else { IdReaderSN = null; } }
public void BlockUnblock() { WorkingThread <object> aWorkingThread1 = new WorkingThread <object>(); WorkingThread <object> aWorkingThread2 = new WorkingThread <object>(); Action <object> aProcessingCallback = x => {}; aWorkingThread1.RegisterMessageHandler(aProcessingCallback); aWorkingThread2.RegisterMessageHandler(aProcessingCallback); aWorkingThread1.UnregisterMessageHandler(); aWorkingThread2.UnregisterMessageHandler(); }
TaskControl AddUserTaskToQueue(WorkCallback workproc, WaitCallback oncomplete, object state) { TaskControl control = new TaskControl(); if (thread == null) { thread = new WorkingThread(); } thread.AddTask(new Task(control, workproc, oncomplete, state)); return(control); }
public void Dispose() { WorkingThread.Enqueue("Cluster Dispose", () => { Logger.Trace <Cluster>("Public Dispose"); _State.LocalNode.SetState(NodeState.NoActive, Resources.LocalDeactivateAsk); _State.LocalNode.SetState(NodeState.NoValid, Resources.ExitApplication); Dispose(true); }); WorkingThread.ControlledStop(); }
private void SetupTest(Action <int> action) { queue = new BlockingCollection <int>(); dispatcher = new WorkItemDispatcherMock(queue, action); thread = new WorkingThread(dispatcher); isThreadCompleted = false; threadException = null; thread.Complete += (object sender, WorkingThread.CompletionEventArgs e) => { isThreadCompleted = true; threadException = e.Exception; Console.WriteLine("thread finished, current thread #{0} {1}, ex={2}", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.Name, threadException); }; }
public void Add(HistoryItems item, string user = "", string dep = "", string state = "", string map = "", string cause = "") { WorkingThread.Enqueue("", () => { AddItem(new HistoryItem() { Date = DateTime.Now, Code = item, User = user, Dep = dep, State = state, Map = map, Cause = cause }); Logger.Info <History>($"HIST {item}, user: {user}, dep: {dep}, state:{state}, map: {map}, cause: {cause}"); }); }
public void UnregisterMessageHandler(string receiverId) { using (EneterTrace.Entering()) { WorkingThread <object> aWorkingThread = null; using (ThreadLock.Lock(myRegisteredMessageHandlers)) { myRegisteredMessageHandlers.TryGetValue(receiverId, out aWorkingThread); myRegisteredMessageHandlers.Remove(receiverId); } if (aWorkingThread != null) { aWorkingThread.UnregisterMessageHandler(); } } }
public override IDisposable Publish() { lock (_lock) { switch (State) { case ObservableState.Disposed: throw new ObjectDisposedException("All observers already disposed"); case ObservableState.Producing: throw new PublishingStartedException("Publishing already started"); default: WorkingThread.Start(); return(_disposer.Value); } } }
public void RegisterMessageHandler(string receiverId, Action <object> messageHandler) { using (EneterTrace.Entering()) { using (ThreadLock.Lock(myRegisteredMessageHandlers)) { if (myRegisteredMessageHandlers.ContainsKey(receiverId)) { string aMessage = "The receiver '" + receiverId + "' is already registered."; EneterTrace.Error(aMessage); throw new InvalidOperationException(aMessage); } // Create and register the working thread for the registering input channel. WorkingThread <object> aWorkingThread = new WorkingThread <object>(); aWorkingThread.RegisterMessageHandler(messageHandler); myRegisteredMessageHandlers[receiverId] = aWorkingThread; } } }
public void SendMessage(string receiverId, object message) { using (EneterTrace.Entering()) { // Get the thread handling the input channel. WorkingThread <object> aWorkingThread = null; using (ThreadLock.Lock(myRegisteredMessageHandlers)) { myRegisteredMessageHandlers.TryGetValue(receiverId, out aWorkingThread); } if (aWorkingThread != null) { aWorkingThread.EnqueueMessage(message); } else { string anError = "The receiver '" + receiverId + "' does not exist."; EneterTrace.Error(anError); throw new InvalidOperationException(anError); } } }
/// <summary> /// 恢复 /// </summary> public void Resume() => WorkingThread?.Resume();
/// <summary> /// 终止线程 /// </summary> public void Abort() => WorkingThread?.Abort();
/// <summary> /// /// </summary> public void Join() => WorkingThread?.Join();
/// <summary> /// 挂起线程 /// </summary> public void Suspend() => WorkingThread?.Suspend();
public void Dispose() { WorkingThread.ControlledStop(); }
/// <summary> /// 启动 /// </summary> public void Start() => WorkingThread?.Start();
internal void Stop() { _stop = true; WorkingThread.Join(); }
public void Stop() { WorkingThread.Abort(); OnPropertyChanged("IsRunning"); }
void Start() { if( thread == null ) thread = new WorkingThread(); }
void Start() { DontDestroyOnLoad(gameObject); if( thread == null ) thread = new WorkingThread(); }
TaskControl AddUserTaskToQueue( WorkCallback workproc, WaitCallback oncomplete, object state ) { TaskControl control = new TaskControl(); if( thread == null ) thread = new WorkingThread(); thread.AddTask(new Task(control,workproc,oncomplete,state)); return control; }