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;
}
