/// <summary> /// Releases resources used by the synchronized block. /// </summary> protected virtual void Dispose(bool disposing) { if (disposing && this.IsLockTaken) { SystemMonitor.Exit(this.SyncObject); } }
public void TestMethod1() { var m = new Monitor(true); m.Start(); Thread.Sleep(10*1000); }
protected ViewerCache() { monitor = new Monitor(); int cacheSize = (Console.WindowHeight - 15)/2; cache = new string[cacheSize + Math.Abs(cacheSize / 2)]; reportCache = new string[cacheSize - Math.Abs(cacheSize / 2)]; Updated = false; indexer = 0; reportIndexer = 0; }
public void TestFieldWithSameNameAsVariable() { ExpressionContext context = new ExpressionContext(null, new Monitor()); context.Variables.Add("doubleA", new ExpressionOwner()); this.AssertCompileException("doubleA.doubleA", context); // But it should work for a public member context = new ExpressionContext(); Monitor m = new Monitor(); context.Variables.Add("I", m); var e = new DynamicExpression("i.i", ExpressionLanguage.Flee); Assert.AreEqual(m.I, (int)e.Invoke(context)); }
public static void Main() { NetworkLayer net = Singleton.Instance; if (net == null) { Debug.Print("Failed to initialize network layer"); return; } Monitor monitor = new Monitor(); NetworkTest test = new NetworkTest(net, monitor); test.Run(null); }
public static void Run() { ManualResetEvent[] handles = new ManualResetEvent[mCount]; Console.WriteLine("main thread id:{0}", Thread.CurrentThread.ManagedThreadId); for (int i = 0; i < mCount; i++) { handles[i] = new ManualResetEvent(false); Monitor monitor = new Monitor(handles[i]); ThreadPool.QueueUserWorkItem(monitor.Dispaly, new {num = 2});//parameter is a anonymous type } WaitHandle.WaitAll(handles); Console.WriteLine("completed."); }
public void Invoke(Action action) { // Execute now if already on the thread if (Thread.CurrentThread == _thread) { action(); } else { lock (action) { // Schedule action InvokeLater(action); // Wait for action to complete ThreadMonitor.Wait(action); } } }
public void CancelTest() { var task = new Monitor(); var count = 0; task.Execute(token => { while (count != 100) { count++; token.ThrowIfCancellationRequested(); Thread.Sleep(100); } }); Assert.True(task.IsRunning); task.Cancel(); Assert.True(task.IsCanceled); Assert.False(task.IsRunning); Assert.AreNotEqual(100, count); }
public void ProcessJobs() { if (Thread.CurrentThread != _thread) { throw new InvalidOperationException("Unable to process jobs on a different thread."); } lock (_queue) { // Process all jobs while (_queue.Count > 0) { var action = _queue.Dequeue(); lock (action) { action(); // ThreadMonitor.PulseAll(action); } } } }
public void DefaultTest() { var messages = 0; var warnings = 0; var exceptions = 0; var task = new Monitor(); task.Message += (sender, args) => { messages++; }; task.Exception += (sender, args) => { exceptions++; }; task.Warning += (sender, args) => { warnings++; }; task.Execute(token => { task.OnMessage("m1"); task.OnMessage("m2"); task.OnMessage("m3"); Thread.Sleep(200); task.OnWarning("w1"); task.OnWarning("w2"); task.OnException(new Exception()); }); Assert.AreEqual(true, task.IsRunning); task.Wait(); Assert.AreEqual(3, messages); Assert.AreEqual(2, warnings); Assert.AreEqual(1, exceptions); }
public void TestComplexMonitor() { this.Test(async() => { object syncObject = new object(); bool waiting = false; List <string> log = new List <string>(); Task t1 = Task.Run(() => { Monitor.Enter(syncObject); log.Add("waiting"); waiting = true; Monitor.Wait(syncObject); log.Add("received pulse"); Monitor.Exit(syncObject); }); Task t2 = Task.Run(async() => { while (!waiting) { await Task.Delay(1); } Monitor.Enter(syncObject); Monitor.Pulse(syncObject); log.Add("pulsed"); Monitor.Exit(syncObject); }); await Task.WhenAll(t1, t2); string expected = "waiting, pulsed, received pulse"; string actual = string.Join(", ", log); Specification.Assert(expected == actual, "ControlledMonitor out of order, '{0}' instead of '{1}'", actual, expected); }, this.GetConfiguration()); }
/// <summary>Gets an enumerable of the tasks currently scheduled on this scheduler.</summary> /// <returns>An enumerable of the tasks currently scheduled.</returns> protected sealed override IEnumerable <Task> GetScheduledTasks() { bool lockTaken = false; try { Monitor.TryEnter(_tasks, ref lockTaken); if (lockTaken) { return(_tasks); } else { throw new NotSupportedException(); } } finally { if (lockTaken) { Monitor.Exit(_tasks); } } }
/// <summary> /// Notifies all waiting threads of a change in the object's state. /// </summary> public virtual void PulseAll() => SystemMonitor.PulseAll(this.SyncObject);
/// <summary> /// Releases the lock on an object and blocks the current thread until it reacquires /// the lock. /// </summary> /// <returns>True if the call returned because the caller reacquired the lock for the specified /// object. This method does not return if the lock is not reacquired.</returns> public virtual bool Wait() => SystemMonitor.Wait(this.SyncObject);
public void setMonitor(Monitor theMonitor) { GateInfoResponse gateInfoResponse = new GateInfoResponse(); try { gateInfoResponse = server.getGateInfo(AppConfig.gateSensor, theMonitor.gateNo); } catch (Exception ex) { Console.WriteLine(ex.Message); } if (gateInfoResponse.error_code != 0) { MessageBox.Show("获取监控信息失败:" + gateInfoResponse.error_msg); toolStripStatusLabel.Text = "获取监控信息失败:" + gateInfoResponse.error_msg; } else { NVRDevice device = new NVRDevice(); device.IP = gateInfoResponse.nvr_ip; device.password = gateInfoResponse.nvr_passwd; device.port = gateInfoResponse.nvr_port; device.username = gateInfoResponse.nvr_username; theMonitor.nvrDevice = device; theMonitor.channel = gateInfoResponse.nvr_channel; if (this.monitor != null) { if (this.monitor.gateNo != theMonitor.gateNo) { toolStripStatusLabel.Text = "正在关闭现有视频!"; stopCurrentPreview(); if (this.monitor.nvrDevice != null && this.monitor.nvrDevice.IP != theMonitor.nvrDevice.IP) { //新监控和原监控的nvr不同,需要logout原nvr toolStripStatusLabel.Text = "正在注销当前NVR!"; this.logout(this.monitor.nvrDevice); } toolStripStatusLabel.Text = "就绪!"; } stop(); } this.monitor = theMonitor; } }
/// <summary> /// Enters the lock. /// </summary> /// <returns>The synchronized block.</returns> protected virtual SynchronizedBlock EnterLock() { SystemMonitor.Enter(this.SyncObject, ref this.IsLockTaken); return(this); }
/// <summary> /// Notifies a thread in the waiting queue of a change in the locked object's state. /// </summary> internal virtual void Pulse() => SystemMonitor.Pulse(this.SyncObject);
/// <summary> /// Initializes a new instance of the <see cref="GISTrainer"/> class with a specified evaluation monitor. /// </summary> /// <param name="monitor">The evaluation monitor.</param> public GISTrainer(Monitor monitor) : this() { this.monitor = monitor; }
public StylusAcquisition(PolhemusController controller, SingleShot singleShot, Monitor monitor = null) { if (controller == null) throw new ArgumentNullException("controller"); if (singleShot == null) throw new ArgumentNullException("singleShot"); _controller = controller; _singleShot = singleShot; _monitor = monitor; _continuousMode = false; initialization(); if (monitor != null) ProgressChanged += new ProgressChangedEventHandler(sa_StylusProgressChanged); }
//monitor only, independent of button state; stops on cancel only public StylusAcquisition(PolhemusController controller, Monitor monitor) { if (controller == null) throw new ArgumentNullException("controller"); if (monitor == null) throw new ArgumentNullException("monitor"); _controller = controller; _monitor = monitor; _continuousMode = true; initialization(); ProgressChanged += new ProgressChangedEventHandler(sa_StylusProgressChanged); }
/// <summary> /// Blocks the current thread until it can enter the <see cref="SemaphoreSlim"/>, /// using a 32-bit signed integer to measure the time interval, /// while observing a <see cref="T:System.Threading.CancellationToken"/>. /// </summary> /// <param name="millisecondsTimeout">The number of milliseconds to wait, or <see cref="Timeout.Infinite"/>(-1) to /// wait indefinitely.</param> /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> to observe.</param> /// <returns>true if the current thread successfully entered the <see cref="SemaphoreSlim"/>; otherwise, false.</returns> /// <exception cref="ArgumentOutOfRangeException"><paramref name="millisecondsTimeout"/> is a negative number other than -1, /// which represents an infinite time-out.</exception> /// <exception cref="System.OperationCanceledException"><paramref name="cancellationToken"/> was canceled.</exception> public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken) { CheckDispose(); // Validate input if (millisecondsTimeout < -1) { throw new ArgumentOutOfRangeException( "totalMilliSeconds", millisecondsTimeout, GetResourceString("SemaphoreSlim_Wait_TimeoutWrong")); } cancellationToken.ThrowIfCancellationRequested(); long startTimeTicks = 0; if (millisecondsTimeout != Timeout.Infinite && millisecondsTimeout > 0) { startTimeTicks = DateTime.UtcNow.Ticks; } bool lockTaken = false; //Register for cancellation outside of the main lock. //NOTE: Register/deregister inside the lock can deadlock as different lock acquisition orders could // occur for (1)this.m_lockObj and (2)cts.internalLock CancellationTokenRegistration cancellationTokenRegistration = cancellationToken.Register(s_cancellationTokenCanceledEventHandler, this); try { // Perf: first spin wait for the count to be positive, but only up to the first planned yield. // This additional amount of spinwaiting in addition // to Monitor2.Enter()’s spinwaiting has shown measurable perf gains in test scenarios. // SpinWait spin = new SpinWait(); while (m_currentCount == 0 && !spin.NextSpinWillYield) { spin.SpinOnce(); } // entering the lock and incrementing waiters must not suffer a thread-abort, else we cannot // clean up m_waitCount correctly, which may lead to deadlock due to non-woken waiters. try { } finally { Monitor2.Enter(m_lockObj, ref lockTaken); if (lockTaken) { m_waitCount++; } } // If the count > 0 we are good to move on. // If not, then wait if we were given allowed some wait duration if (m_currentCount == 0) { if (millisecondsTimeout == 0) { return(false); } // Prepare for the main wait... // wait until the count become greater than zero or the timeout is expired if (!WaitUntilCountOrTimeout(millisecondsTimeout, startTimeTicks, cancellationToken)) { return(false); } } // At this point the count should be greater than zero Contract.Assert(m_currentCount > 0); m_currentCount--; // Exposing wait handle which is lazily initialized if needed if (m_waitHandle != null && m_currentCount == 0) { m_waitHandle.Reset(); } } finally { // Release the lock if (lockTaken) { m_waitCount--; Monitor.Exit(m_lockObj); } // Unregister the cancellation callback. cancellationTokenRegistration.Dispose(); } return(true); }
/// <summary> /// Releases the lock on an object and blocks the current thread until it reacquires /// the lock. /// </summary> /// <returns>True if the call returned because the caller reacquired the lock for the specified /// object. This method does not return if the lock is not reacquired.</returns> internal virtual bool Wait() => SystemMonitor.Wait(this.SyncObject);
public static event EventHandler GatewayCacheUpdated = null; //Notify the UI to pull the latest data update //Interface static ActiveGateway() { _Data = new DataSet(); _Monitor = new Monitor(7500); _Monitor.DataUpdate += new DataEventHandler(OnDataUpdate); }
protected Parking() { monitor = new Monitor(); reservations = new List<ParkingReservation>(); open = true; }
/// <summary> /// Releases the lock on an object and blocks the current thread until it reacquires /// the lock. If the specified time-out interval elapses, the thread enters the ready /// queue. /// </summary> /// <param name="millisecondsTimeout">The number of milliseconds to wait before the thread enters the ready queue.</param> /// <returns>True if the lock was reacquired before the specified time elapsed; false if the /// lock was reacquired after the specified time elapsed. The method does not return /// until the lock is reacquired.</returns> public virtual bool Wait(int millisecondsTimeout) => SystemMonitor.Wait(this.SyncObject, millisecondsTimeout);
/// <summary> /// Releases the lock on an object and blocks the current thread until it reacquires /// the lock. If the specified time-out interval elapses, the thread enters the ready /// queue. /// </summary> /// <param name="timeout">A System.TimeSpan representing the amount of time to wait before the thread enters /// the ready queue.</param> /// <returns>True if the lock was reacquired before the specified time elapsed; false if the /// lock was reacquired after the specified time elapsed. The method does not return /// until the lock is reacquired.</returns> public virtual bool Wait(TimeSpan timeout) => SystemMonitor.Wait(this.SyncObject, timeout);
/// <summary> /// Blocks the current thread until the current <see cref="ManualResetEventSlim"/> is set, using a /// 32-bit signed integer to measure the time interval, while observing a <see /// cref="T:System.Threading.CancellationToken"/>. /// </summary> /// <param name="millisecondsTimeout">The number of milliseconds to wait, or <see /// cref="Timeout.Infinite"/>(-1) to wait indefinitely.</param> /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> to /// observe.</param> /// <returns>true if the <see cref="System.Threading.ManualResetEventSlim"/> was set; otherwise, /// false.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="millisecondsTimeout"/> is a /// negative number other than -1, which represents an infinite time-out.</exception> /// <exception cref="T:System.InvalidOperationException"> /// The maximum number of waiters has been exceeded. /// </exception> /// <exception cref="T:System.Threading.OperationCanceledException"><paramref /// name="cancellationToken"/> was canceled.</exception> public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken) { ThrowIfDisposed(); cancellationToken.ThrowIfCancellationRequested(); // an early convenience check if (millisecondsTimeout < -1) { throw new ArgumentOutOfRangeException(nameof(millisecondsTimeout)); } if (!IsSet) { if (millisecondsTimeout == 0) { // For 0-timeouts, we just return immediately. return(false); } // We spin briefly before falling back to allocating and/or waiting on a true event. uint startTime = 0; bool bNeedTimeoutAdjustment = false; int realMillisecondsTimeout = millisecondsTimeout; //this will be adjusted if necessary. if (millisecondsTimeout != Timeout.Infinite) { // We will account for time spent spinning, so that we can decrement it from our // timeout. In most cases the time spent in this section will be negligible. But // we can't discount the possibility of our thread being switched out for a lengthy // period of time. The timeout adjustments only take effect when and if we actually // decide to block in the kernel below. startTime = TimeoutHelper.GetTime(); bNeedTimeoutAdjustment = true; } // Spin int spinCount = SpinCount; var spinner = new SpinWait(); while (spinner.Count < spinCount) { spinner.SpinOnce(SpinWait.Sleep1ThresholdForLongSpinBeforeWait); if (IsSet) { return(true); } if (spinner.Count >= 100 && spinner.Count % 10 == 0) // check the cancellation token if the user passed a very large spin count { cancellationToken.ThrowIfCancellationRequested(); } } // Now enter the lock and wait. EnsureLockObjectCreated(); // We must register and unregister the token outside of the lock, to avoid deadlocks. using (cancellationToken.UnsafeRegister(s_cancellationTokenCallback, this)) { lock (m_lock) { // Loop to cope with spurious wakeups from other waits being canceled while (!IsSet) { // If our token was canceled, we must throw and exit. cancellationToken.ThrowIfCancellationRequested(); //update timeout (delays in wait commencement are due to spinning and/or spurious wakeups from other waits being canceled) if (bNeedTimeoutAdjustment) { realMillisecondsTimeout = TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout); if (realMillisecondsTimeout <= 0) { return(false); } } // There is a race condition that Set will fail to see that there are waiters as Set does not take the lock, // so after updating waiters, we must check IsSet again. // Also, we must ensure there cannot be any reordering of the assignment to Waiters and the // read from IsSet. This is guaranteed as Waiters{set;} involves an Interlocked.CompareExchange // operation which provides a full memory barrier. // If we see IsSet=false, then we are guaranteed that Set() will see that we are // waiting and will pulse the monitor correctly. Waiters = Waiters + 1; if (IsSet) //This check must occur after updating Waiters. { Waiters--; //revert the increment. return(true); } // Now finally perform the wait. try { // ** the actual wait ** if (!Monitor.Wait(m_lock, realMillisecondsTimeout)) { return(false); //return immediately if the timeout has expired. } } finally { // Clean up: we're done waiting. Waiters = Waiters - 1; } // Now just loop back around, and the right thing will happen. Either: // 1. We had a spurious wake-up due to some other wait being canceled via a different cancellationToken (rewait) // or 2. the wait was successful. (the loop will break) } } } } // automatically disposes (and unregisters) the callback return(true); //done. The wait was satisfied. }