StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>You need some mechanism to make a "queue control", coordinating steps according to the order you want them occurring.</p> <p>Recently I have needed to implement something like this to force a specific order in the execution of several threads in a unit test.</p> <p>Here is my suggestion:</p> <p><strong>QueueSynchronizer:</strong></p> <pre><code>/// <summary> /// Synchronizes steps between threads. /// </summary> public class QueueSynchronizer { /// <summary> /// Constructor. /// </summary> /// <param name="minWait">Minimum waiting time until the next try.</param> /// <param name="maxWait">Maximum waiting time until the next try.</param> public QueueSynchronizer(Int32 minWait, Int32 maxWait) { } private Mutex mx = new Mutex(); /// <summary> /// Minimum waiting time until the next try. /// </summary> private Int32 minWait = 5; /// <summary> /// Maximum waiting time until the next try. /// </summary> private Int32 maxWait = 500; int currentStep = 1; /// <summary> /// Key: order in the queue; Value: Time to wait. /// </summary> private Dictionary<int, int> waitingTimeForNextMap = new Dictionary<int, int>(); /// <summary> /// Synchronizes by the order in the queue. It starts from 1. If is not /// its turn, the thread waits for a moment, after that, it tries again, /// and so on until its turn. /// </summary> /// <param name="orderInTheQueue">Order in the queue. It starts from 1.</param> /// <returns>The <see cref="Mutex"/>The mutex that must be released at the end of turn. /// </returns> public Mutex Sincronize(int orderInTheQueue) { do { //while it is not the turn, the thread will stay in this loop and sleeping for 100, 200, ... 1000 ms if (orderInTheQueue != this.currentStep) { //The next in queue will be waiting here (other threads). mx.WaitOne(); mx.ReleaseMutex(); //Prevents 100% processing while the current step does not happen if (!waitingTimeForNextMap.ContainsKey(orderInTheQueue)) { waitingTimeForNextMap[orderInTheQueue] = this.minWait; } Thread.Sleep(waitingTimeForNextMap[orderInTheQueue]); waitingTimeForNextMap[orderInTheQueue] = Math.Min(waitingTimeForNextMap[orderInTheQueue] * 2, this.maxWait); } } while (orderInTheQueue != this.currentStep); mx.WaitOne(); currentStep++; return mx; } } </code></pre> <p><code>Start()</code> and <code>Close()</code> with <code>QueueSynchronizer</code>: </p> <pre><code>//synchronizer private static QueueSynchronizer queueSynchronizer; private static Thread instanceCaller; private static WaitForm instance; private static AutoResetEvent waitFormStarted = new AutoResetEvent(false); private static object locker = new object(); /// <summary> /// Initializes WaitForm to start a single task /// </summary> /// <param name="header">WaitForm header</param> /// <param name="message">Message displayed</param> /// <param name="showProgressBar">True if we want a progress bar, else false</param> public static void Start(string header, string message, bool showProgressBar) { queueSynchronizer = new QueueSynchronizer(); InitializeCallerThread(showProgressBar, header, message); instanceCaller.Start(); } /// <summary> /// Initializes caller thread for executing a single command /// </summary> /// <param name="showProgressBar"></param> /// <param name="header"></param> /// <param name="message"></param> private static void InitializeCallerThread(bool showProgressBar, string header, string message) { waitFormStarted.Reset(); instanceCaller = new Thread(() => { lock (locker) { //Queuing to run on first. Mutex mx = queueSynchronizer.Sincronize(1); try { instance = new WaitForm() { Header = header, Message = message, IsProgressBarVisible = showProgressBar }; } finally { //I think is here that ends the first step!? mx.ReleaseMutex(); } waitFormStarted.Set(); } instance.ShowDialog(); }); instanceCaller.Name = "WaitForm thread"; instanceCaller.SetApartmentState(ApartmentState.STA); instanceCaller.IsBackground = true; } /// <summary> /// Closes current form /// </summary> public static void Close() { //Queuing to run on second. Mutex mx = queueSynchronizer.Sincronize(2); try { lock (locker) { if (instance != null && !instance.IsClosed) { waitFormStarted.WaitOne(); instance.FinalizeWork(); instance.Dispatcher.Invoke( new Action(() => { instance.Close(); })); } } } finally { mx.ReleaseMutex(); } } </code></pre>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload