System.Threading.Monitor.Exit(object)

protected virtual void Dispose(bool disposing) {
        if (disposing)
            Monitor.Exit(m_pObject);
    }

public void Dispose()
            {
                inContext = false;

                invocationSymbol = null;
                statementSymbol = null;

                expressionSyntax = null;
                statementSyntax = null;

                callerInfo = null;
                callerSymbol = null;

                methodInfo = null;
                methodSymbol = null;

                Monitor.Exit(syncObject);
            }

[HarmonyPostfix]
            public static void Postfix()
            {
                Monitor.Exit(SuncObj);
            }

[HarmonyPostfix]
            public static void Postfix()
            {
                Monitor.Exit(ThingOwnerUtility_GetAllThingsRecursively_Patch.SuncObj);
            }

private static void IncreaseCommentFormatTypesPrioirity(IClreplacedificationTypeRegistryService registry, IClreplacedificationFormatMapService formatMapService,
                                                               IClreplacedificationType highestPriorityType)
        {
            bool lockTaken = false;
            Monitor.TryEnter(_syncRoot, ref lockTaken);

            if (lockTaken)
            {
                try
                {
                    if (!_isPriorityIncreased)
                    {
                        _isPriorityIncreased = true;
                        IClreplacedificationFormatMap formatMap = formatMapService.GetClreplacedificationFormatMap(category: TextCategory);
                        IncreaseServiceFormatPriority(formatMap, registry, PredefinedClreplacedificationTypeNames.ExcludedCode, highestPriorityType);
                        IncreaseServiceFormatPriority(formatMap, registry, PredefinedClreplacedificationTypeNames.Comment, highestPriorityType);
                    }
                }
                finally
                {
                    Monitor.Exit(_syncRoot);
                }
            }
        }

protected void OnLoadingStarted()
        {
            var obj = _syncHandle;
            var lockTaken = false;

            try
            {
                Monitor.Enter(obj, ref lockTaken);
                CancellationTokenSource = new CancellationTokenSource();
            }
            finally
            {
                if (lockTaken)
                    Monitor.Exit(obj);
            }
        }

protected void OnLoadingCompleted(bool cancelled)
        {
            if (!IsLoading || this._completionSource == null)
                return;

            var completionSource = Interlocked.Exchange(ref this._completionSource, null);
            completionSource?.SetResult(cancelled);

            var obj = _syncHandle;
            var lockTaken = false;

            try
            {
                Monitor.Enter(obj, ref lockTaken);
                CancellationTokenSource = null;
            }
            finally
            {
                if (lockTaken)
                    Monitor.Exit(obj);
            }
        }

public void Unlock(string name)
		{
			lock (_locks)
			{
				ReferenceCount obj;

				_locks.TryGetValue(name, out obj);

				if (obj != null)
				{
					Monitor.Exit(obj);

					if (0 == obj.Release())
					{
						_locks.Remove(name);
					}
				}
			}
		}

public IDisposable Lock(string name, int millisecondsTimeout)
		{
			Monitor.Enter(_locks);

			ReferenceCount obj;

			_locks.TryGetValue(name, out obj);

			if (obj == null)
			{
				obj = new ReferenceCount();

				Monitor.Enter(obj);

				_locks.Add(name, obj);

				Monitor.Exit(_locks);
			}
			else
			{
				obj.AddRef();

				Monitor.Exit(_locks);

				if (!Monitor.TryEnter(obj, millisecondsTimeout))
				{
					throw new TimeoutException(string.Format("A timeout occurred while waiting on the named lock {0}.", name));
				}
			}

			return new NamedLockHandle(this, name);
		}

private IDatabase CreateClient(int db)
        {
            Monitor.Enter(LockObj);
            try
            {
                if (connect == null)
                {
                    connect = ConnectionMultiplexer.Connect($"{Address}:{Port}");
                }
                if (_client != null && _db == db)
                    return _client;
                return connect.GetDatabase(db);
            }
            finally
            {
                Monitor.Exit(LockObj);
            }
        }

public void Dispose()
        {
            if (connect == null)
                return;
            Monitor.Enter(LockObj);
            try
            {
                connect.Close();
                connect.Dispose();
            }
            finally
            {
                Monitor.Exit(LockObj);
            }
        }

private RedisClient CreateClient(long db)
        {
            Monitor.Enter(LockObj);
            try
            {
                //var dbid = (this.db << 16);
                return new RedisClient(Address, Port, PreplacedWord, db)
                {
                    RetryCount = 50,
                    RetryTimeout = 5000
                };
                /*List<RedisClient> used;
                    if (!Used.ContainsKey(dbid))
                    {
                        Used.Add(dbid, used = new List<RedisClient>());
                        Idle.Add(dbid, new List<RedisClient>());

                        _client = new RedisClient(Address, Port, null, db)
                        {
                            RetryCount = 50,
                            RetryTimeout = 5000
                        };
                        used.Add(_client);
                        return Client;
                    }
                    used = Used[dbid];
                    List<RedisClient> idle = Idle[dbid];
                    while (idle.Count > 0 && idle[0] == null)
                    {
                        idle.RemoveAt(0);
                    }
                    if (idle.Count == 0)
                    {
                        _client = new RedisClient(Address, Port, null, db)
                        {
                            RetryCount = 50,
                            RetryTimeout = 5000
                        };
                        used.Add(_client);
                        return _client;
                    }
                    _client = idle[0];
                    idle.RemoveAt(0);
#if DEBUG
                    _client.Ping();
#endif
                    used.Add(_client);
                    return _client;*/
            }
            finally
            {
                Monitor.Exit(LockObj);
            }
        }

public void Dispose()
        {
            if (_client == null)
                return;
            Monitor.Enter(LockObj);
            try
            {
                //int dbid = (_db << 16);
                //Used[dbid].Remove(_client);
                _client.ResetSendBuffer();
                //if (_client.HadExceptions || Idle[dbid].Count > PoolSize)
                {
                    _client.Quit();
                    _client.Dispose();
                }
                //else
                //{
                //    Idle[dbid].Add(_client);
                //}
            }
            finally
            {
                Monitor.Exit(LockObj);
            }
        }

protected override void OnDispose()
        {
            Monitor.Exit(_lockObject);
        }

private IDatabase CreateClient(int db)
        {
            Monitor.Enter(LockObj);
            try
            {
                if (_client == null || db != _client.Database)
                    _client = _connect.GetDatabase(db);
                _db = _client.Database;
                return _client;
            }
            catch (Exception ex)
            {
                LogRecorderX.Exception(ex, ConnectString);
                throw;
            }
            finally
            {
                Monitor.Exit(LockObj);
            }
        }

public void Dispose()
        {
            if (IsDisposed)
                return;
            IsDisposed = true;
            ShimHandler.Close();
            Monitor.Enter(ShimHandler);
            Monitor.Exit(ShimHandler);
            _actor.Dispose();
            _messagesPipe.Options.Linger = TimeSpan.Zero;
            _messagesPipe.Dispose();
        }

protected override void OnDispose()
        {
            Monitor.Exit(_lockObj);
            _closeAction?.Invoke();
        }

public void Close()
        {
            if (!isRuning)
                return;
            isRuning = true;
            Stream.Unbind(Address);
            MessagesPipe.Disconnect($"inproc://wsrouter-{Id}");

            Poller.Dispose();
            Monitor.Enter(this);
            try
            {
                Stream.Dispose();
                MessagesPipe.Dispose();
            }
            finally
            {
                Monitor.Exit(this);
            }
        }

public void Run(PairSocket shim)
        {
            string shimAdd = $"inproc://wsrouter-{Id}";
            Monitor.Enter(this);
            try
            {
                isRuning = true;
                shim.SignalOK();

                shim.ReceiveReady += OnShimReady;

                MessagesPipe = new PairSocket();
                MessagesPipe.Connect(shimAdd);
                MessagesPipe.ReceiveReady += OnMessagePipeReady;

                Stream = new StreamSocket();
                Stream.Bind(Address);
                Stream.ReceiveReady += OnStreamReady;

                Poller = new NetMQPoller
                {
                    MessagesPipe,
                    shim,
                    Stream
                };
                MessagesPipe.SignalOK();
                Poller.Run();
                shim.Dispose();
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex);
            }
            finally
            {
                Monitor.Exit(this);
            }
        }

internal IKeyRing GetCurrentKeyRingCore(DateTime utcNow, bool forceRefresh = false)
        {
            Debug.replacedert(utcNow.Kind == DateTimeKind.Utc);

            // Can we return the cached keyring to the caller?
            CacheableKeyRing existingCacheableKeyRing = null;
            if (!forceRefresh)
            {
                existingCacheableKeyRing = Volatile.Read(ref _cacheableKeyRing);
                if (CacheableKeyRing.IsValid(existingCacheableKeyRing, utcNow))
                {
                    return existingCacheableKeyRing.KeyRing;
                }
            }

            // The cached keyring hasn't been created or must be refreshed. We'll allow one thread to
            // update the keyring, and all other threads will continue to use the existing cached
            // keyring while the first thread performs the update. There is an exception: if there
            // is no usable existing cached keyring, all callers must block until the keyring exists.
            var acquiredLock = false;
            try
            {
                Monitor.TryEnter(_cacheableKeyRingLockObj, (existingCacheableKeyRing != null) ? 0 : Timeout.Infinite, ref acquiredLock);
                if (acquiredLock)
                {
                    return GetCurrentKeyRingSync(utcNow, forceRefresh, ref existingCacheableKeyRing);
                }
                else
                {
                    // We didn't acquire the critical section. This should only occur if we preplaceded
                    // zero for the Monitor.TryEnter timeout, which implies that we had an existing
                    // (but outdated) keyring that we can use as a fallback.
                    Debug.replacedert(existingCacheableKeyRing != null);
#pragma warning disable S2259 // Null pointers should not be dereferenced
                    return existingCacheableKeyRing.KeyRing;
#pragma warning restore S2259 // Null pointers should not be dereferenced
                }
            }
            finally
            {
                if (acquiredLock)
                {
                    Monitor.Exit(_cacheableKeyRingLockObj);
                }
            }
        }

bool Offer(TimedTask tt)
        {
            lock (queue)
            {
                queue.Add(tt);
            }
            if (Volatile.Read(ref shutdown))
            {
                lock (queue)
                {
                    queue.Clear();
                }
                return false;
            }
            else
            {
                Monitor.Enter(this);
                Monitor.Pulse(this);
                Monitor.Exit(this);
            }
            return true;
        }

public void Run()
        {
            for (;;)
            {
                if (SubscriptionHelper.IsCancelled(ref upstream))
                {
                    return;
                }
                if (Volatile.Read(ref wip) == 0)
                {
                    Monitor.Enter(this);
                    try
                    {
                        for (;;)
                        {
                            if (SubscriptionHelper.IsCancelled(ref upstream))
                            {
                                return;
                            }

                            if (Volatile.Read(ref wip) != 0)
                            {
                                break;
                            }
                            Monitor.Wait(this);
                        }
                    }
                    finally
                    {
                        Monitor.Exit(this);
                    }
                }
                if (queue.Poll(out T current))
                {
                    int c = consumed + 1;
                    if (c == limit)
                    {
                        consumed = 0;
                        upstream.Request(c);
                    }
                    else
                    {
                        consumed = c;
                    }
                    onNext(current);
                    Interlocked.Decrement(ref wip);
                    continue;
                }
                var ex = error;
                if (ex != null)
                {
                    onError(ex);
                }
                else
                {
                    onComplete();
                }
                return;
            }
        }

void Unblock()
        {
            if (Interlocked.Increment(ref wip) == 1)
            {
                Monitor.Enter(this);
                Monitor.Pulse(this);
                Monitor.Exit(this);
            }
        }

public bool MoveNext()
        {
            if (SubscriptionHelper.IsCancelled(ref upstream))
            {
                return false;
            }
            if (Volatile.Read(ref wip) == 0)
            {
                Monitor.Enter(this);
                try
                {
                    for (;;)
                    {
                        if (SubscriptionHelper.IsCancelled(ref upstream))
                        {
                            return false;
                        }

                        if (Volatile.Read(ref wip) != 0)
                        {
                            break;
                        }
                        Monitor.Wait(this);
                    }
                }
                finally
                {
                    Monitor.Exit(this);
                }
            }
            if (queue.Poll(out current))
            {
                int c = consumed + 1;
                if (c == limit)
                {
                    consumed = 0;
                    upstream.Request(c);
                }
                else
                {
                    consumed = c;
                }
                Interlocked.Decrement(ref wip);
                return true;
            }
            var ex = error;
            if (ex != null)
            {
                throw ex;
            }
            return false;
        }

public void Run()
        {
            var a = actual;
            var q = queue;
            long e = 0L;
            int consumed = 0;
            int lim = limit;
            for (;;)
            {
                if (SubscriptionHelper.IsCancelled(ref upstream))
                {
                    q.Clear();
                    return;
                }
                if (Volatile.Read(ref wip) == 0)
                {
                    Monitor.Enter(this);
                    try
                    {
                        while (Volatile.Read(ref wip) == 0 && SubscriptionHelper.IsCancelled(ref upstream))
                        {
                            Monitor.Wait(this);
                        }
                    }
                    finally
                    {
                        Monitor.Exit(this);
                    }
                }
                if (SubscriptionHelper.IsCancelled(ref upstream))
                {
                    q.Clear();
                    return;
                }

                bool d = Volatile.Read(ref done);
                bool empty = q.IsEmpty();

                if (d && empty)
                {
                    var ex = error;
                    if (ex != null)
                    {
                        a.OnError(ex);
                    }
                    else
                    {
                        a.OnComplete();
                    }
                    return;
                }

                if (!empty)
                {
                    if (e != Volatile.Read(ref requested))
                    {
                        q.Poll(out T v);

                        a.OnNext(v);

                        e++;
                        if (++consumed == lim)
                        {
                            consumed = 0;
                            upstream.Request(lim);
                        }    
                    }
                }
                Interlocked.Decrement(ref wip);
            }
        }

internal bool Offer(Action task)
        {
            if (Volatile.Read(ref shutdown) == 0)
            {
                queue.Offer(task);
                if (Interlocked.Increment(ref wip) == 1)
                {
                    Monitor.Enter(this);
                    try
                    {
                        Monitor.Pulse(this);
                    }
                    finally
                    {
                        Monitor.Exit(this);
                    }
                }
                return true;
            }
            return false;
        }

internal void Run()
        {
            Thread.CurrentThread.IsBackground = daemon;
            var n = name;
            if (n != null)
            {
                try 
                { 
                    Thread.CurrentThread.Name = n;
                }
                catch (InvalidOperationException)
                {
                    // ignored
                }
            }
            var sh = ShutdownAction;
            var q = queue;
            long missed = 0L;
            for (;;)
            {
                if (Volatile.Read(ref shutdown) != 0)
                {
                    q.Clear();
                    break;
                }
                Action a = null;

                for (int i = 0; i < 64; i++)
                {
                    if (q.Poll(out a))
                    {
                        break;
                    }
                }

                if (a != null)
                {
                    if (a == sh)
                    {
                        q.Clear();
                        break;
                    }
                    try
                    {
                        a();
                    }
                    catch
                    {
                        // TODO what to do with these?
                    }
                }
                else
                {
                    long w = Volatile.Read(ref wip);
                    if (w == missed)
                    {
                        missed = Interlocked.Add(ref wip, -missed);
                        if (missed == 0)
                        {
                            if (Monitor.TryEnter(this))
                            {
                                try
                                {
                                    while ((missed = Volatile.Read(ref wip)) == 0)
                                    {
                                        Monitor.Wait(this);
                                    }
                                }
                                finally
                                {
                                    Monitor.Exit(this);
                                }
                            }
                        }
                    }
                    else
                    {
                        missed = w;
                    }
                }
            }
        }

public void Dispose()
        {
            if (!Volatile.Read(ref shutdown))
            {
                Volatile.Write(ref shutdown, true);
                Monitor.Enter(this);
                Monitor.Pulse(this);
                Monitor.Exit(this);
            }
        }

internal void Run()
        {
            Thread.CurrentThread.IsBackground = true;
            Thread.CurrentThread.Name = name;
            var q = queue;
            for (;;)
            {
                if (Volatile.Read(ref shutdown))
                {
                    lock (q)
                    {
                        q.Clear();
                    }
                    break;
                }
                else
                {
                    long now = SchedulerHelper.NowUTC();
                    TimedTask tt = null;
                    int next = 0;
                    lock (q)
                    {
                        tt = q.FirstOrDefault();
                        if (tt != null)
                        {
                            if (tt.due <= now)
                            {
                                q.Remove(tt);
                            }
                            else
                            if (Volatile.Read(ref tt.action) == null)
                            {
                                q.Remove(tt);
                                continue;
                            }
                            else
                            {
                                next = (int)Math.Max(0, tt.due - now);
                                tt = null;
                            }
                        }
                        else
                        {
                            next = int.MaxValue;
                        }
                    }

                    if (tt != null)
                    {
                        if (Volatile.Read(ref shutdown))
                        {
                            lock (q)
                            {
                                q.Clear();
                            }
                            return;
                        }
                        var a = Volatile.Read(ref tt.action);
                        try
                        {
                            a?.Invoke();
                        }
                        catch
                        {
                            // TODO what should happen here?
                        }
                    }
                    else
                    {
                        if (Volatile.Read(ref shutdown))
                        {
                            lock (q)
                            {
                                q.Clear();
                            }
                            return;
                        }
                        if (Monitor.TryEnter(this))
                        {
                            Monitor.Wait(this, next);
                            Monitor.Exit(this);
                        }
                    }
                }
            }
        }

public void Dispose()
        {
            if (this.lockObject is object)
            {
                Monitor.Exit(this.lockObject);
            }
        }

public void Dispose ()
			{
				Monitor.Exit (_lockPoint);
			}

internal void Add(object obj)
        {
            if (_ctsUpdatingList != null)
            {
                ShowBusyMessage();
                return;
            }
            Monitor.Enter(_lockDownloadItemsList);
            try
            {
                var win = new AddDownloadWindow();
                var vm = new AddDownloadViewModel(AddItemsAsync, win.Preview, _displayMessage);
                win.DataContext = vm;
                win.Owner = obj as Window;
                win.ShowDialog();
            }
            finally
            {
                Monitor.Exit(_lockDownloadItemsList);
            }
        }

internal void Download_Stopped(object sender, EventArgs e)
        {
            if (this.DownloadingCount == 0)
            {
                this.Status = "Ready";
                RaisePropertyChanged(nameof(this.Status));

                if (this.QueuedCount == 0)
                {
                    this.QueueProcessor.Stop();
                }
            }

            RefreshCollection();

            Monitor.Enter(_lockBytesTransferredOverLifetime);
            try
            {
                Settings.Default.BytesTransferredOverLifetime +=
                    (ulong)(sender as DownloaderObjectModel).BytesDownloadedThisSession;
            }
            finally
            {
                Monitor.Exit(_lockBytesTransferredOverLifetime);
            }
        }

private void AddObjects(params DownloaderObjectModel[] objects)
        {
            Monitor.Enter(_lockDownloadItemsList);
            int total = objects.Count();
            try
            {
                Application.Current.Dispatcher.Invoke(() =>
                {
                    for (int i = 0; i < total; i++)
                    {
                        if (objects[i] == null) continue;

                        DownloadItemsList.Add(objects[i]);

                        if (objects[i].IsQueued)
                        {
                            this.QueueProcessor.Add(objects[i]);
                        }
                    }
                });
            }
            catch { }
            finally
            {
                Monitor.Exit(_lockDownloadItemsList);
            }
        }

private async Task RemoveObjectsAsync(bool delete, params DownloaderObjectModel[] objects)
        {
            await _semapreplacedUpdatingList.WaitAsync();

            var dequeueThese = new List<IQueueable>();
            var itemsProcessed = new List<DownloaderObjectModel>();
            var total = objects.Count();
            _ctsUpdatingList = new CancellationTokenSource();
            var ct = _ctsUpdatingList.Token;
            RaisePropertyChanged(nameof(this.IsBackgroundWorking));
            int progress;
            string primaryStatus = "Removing ";
            if (delete) primaryStatus = "Deleting ";
            for (int i = 0; i < total; i++)
            {
                progress = (int)((double)(i + 1) / total * 100);
                this.Status = primaryStatus + (i + 1) + " of " + total + ": " + objects[i].Name;
                this.Progress = progress;
                RaisePropertyChanged(nameof(this.Status));
                RaisePropertyChanged(nameof(this.Progress));

                if (objects[i] == null) continue;

                if (objects[i].IsQueued)
                {
                    objects[i].Dequeue();
                    dequeueThese.Add(objects[i]);
                }

                if (objects[i].IsBeingDownloaded)
                {
                    await objects[i].CancelAsync();
                }
                else
                {
                    // delete all UNFINISHED downloads forcefully
                    if (objects[i].Status != DownloadStatus.Finished || delete)
                    {
                        try
                        {
                            if (objects[i].Status == DownloadStatus.Finished)
                            {
                                FileSystem.DeleteFile(
                                    objects[i].Destination,
                                    UIOption.OnlyErrorDialogs,
                                    RecycleOption.SendToRecycleBin);
                            }
                            else
                            {
                                File.Delete(objects[i].TempDestination);
                            }
                        }
                        catch { }
                    }
                }

                itemsProcessed.Add(objects[i]);

                if (ct.IsCancellationRequested)
                {
                    break;
                }
            }

            this.Status = "Delisting...";
            RaisePropertyChanged(nameof(this.Status));

            Application.Current.Dispatcher.Invoke(() =>
            {
                Monitor.Enter(_lockDownloadItemsList);
                for (int i = 0; i < itemsProcessed.Count(); i++)
                {
                    DownloadItemsList.Remove(itemsProcessed[i]);
                }
                Monitor.Exit(_lockDownloadItemsList);
            });

            if (dequeueThese.Count > 0)
            {
                this.Status = "Refreshing queue...";
                RaisePropertyChanged(nameof(this.Status));
                QueueProcessor.Remove(dequeueThese.ToArray());
            }

            _ctsUpdatingList = null;
            this.Status = "Ready";
            this.Progress = 0;
            RaisePropertyChanged(nameof(this.Status));
            RaisePropertyChanged(nameof(this.Progress));
            RaisePropertyChanged(nameof(this.IsBackgroundWorking));
            _semapreplacedUpdatingList.Release();
        }

public void Dispose()
        {
            Db.Dispose();
            Monitor.Exit(Locker);
        }

public void Disable()
        {
            Monitor.Enter(_lock);
            _canSend = false;
            Monitor.Exit(_lock);
        }

public IDisposable Enter()
        {
            Monitor.Enter(_lock);

            if (_canSend)
                return this;

            Monitor.Exit(_lock);
            throw new OperationCanceledException();
        }

public void Dispose()
            => Monitor.Exit(_lock);

private void EmitPendingBuffers(bool doAll, bool mustWait)
        {
            // When combining parallel deflation with a ZipSegmentedStream, it's
            // possible for the ZSS to throw from within this method.  In that
            // case, Close/Dispose will be called on this stream, if this stream
            // is employed within a using or try/finally pair as required. But
            // this stream is unaware of the pending exception, so the Close()
            // method invokes this method AGAIN.  This can lead to a deadlock.
            // Therefore, failfast if re-entering.

            if (emitting) return;
            emitting = true;
            if (doAll || mustWait)
                _newlyCompressedBlob.WaitOne();

            do
            {
                int firstSkip = -1;
                int millisecondsToWait = doAll ? 200 : (mustWait ? -1 : 0);
                int nextToWrite = -1;

                do
                {
                    if (Monitor.TryEnter(_toWrite, millisecondsToWait))
                    {
                        nextToWrite = -1;
                        try
                        {
                            if (_toWrite.Count > 0)
                                nextToWrite = _toWrite.Dequeue();
                        }
                        finally
                        {
                            Monitor.Exit(_toWrite);
                        }

                        if (nextToWrite >= 0)
                        {
                            WorkItem workitem = _pool[nextToWrite];
                            if (workitem.ordinal != _lastWritten + 1)
                            {
                                // out of order. requeue and try again.
                                TraceOutput(TraceBits.EmitSkip,
                                            "Emit     skip     wi({0}) ord({1}) lw({2}) fs({3})",
                                            workitem.index,
                                            workitem.ordinal,
                                            _lastWritten,
                                            firstSkip);

                                lock(_toWrite)
                                {
                                    _toWrite.Enqueue(nextToWrite);
                                }

                                if (firstSkip == nextToWrite)
                                {
                                    // We went around the list once.
                                    // None of the items in the list is the one we want.
                                    // Now wait for a compressor to signal again.
                                    _newlyCompressedBlob.WaitOne();
                                    firstSkip = -1;
                                }
                                else if (firstSkip == -1)
                                    firstSkip = nextToWrite;

                                continue;
                            }

                            firstSkip = -1;

                            TraceOutput(TraceBits.EmitBegin,
                                        "Emit     begin    wi({0}) ord({1})              cba({2})",
                                        workitem.index,
                                        workitem.ordinal,
                                        workitem.compressedBytesAvailable);

                            _outStream.Write(workitem.compressed, 0, workitem.compressedBytesAvailable);
                            _runningCrc.Combine(workitem.crc, workitem.inputBytesAvailable);
                            _totalBytesProcessed += workitem.inputBytesAvailable;
                            workitem.inputBytesAvailable = 0;

                            TraceOutput(TraceBits.EmitDone,
                                        "Emit     done     wi({0}) ord({1})              cba({2}) mtw({3})",
                                        workitem.index,
                                        workitem.ordinal,
                                        workitem.compressedBytesAvailable,
                                        millisecondsToWait);

                            _lastWritten = workitem.ordinal;
                            _toFill.Enqueue(workitem.index);

                            // don't wait next time through
                            if (millisecondsToWait == -1) millisecondsToWait = 0;
                        }
                    }
                    else
                        nextToWrite = -1;

                } while (nextToWrite >= 0);

            //} while (doAll && (_lastWritten != _latestCompressed));
            } while (doAll && (_lastWritten != _latestCompressed || _lastWritten != _lastFilled));

            emitting = false;
        }

public void ShowWindow()
        {
            ConfigMail.Load();
            ConfigCaptcha.Load();

            BsMail.DataSource = ConfigMail.Running;
            BsCaptcha.DataSource = ConfigCaptcha.Running;

            Monitor.Enter(Misc.CaptchaConfigSync);
            Monitor.Enter(Misc.MailBoxConfigSync);
            var dialogResult = this.ShowDialog();
            Monitor.Exit(Misc.CaptchaConfigSync);
            Monitor.Exit(Misc.MailBoxConfigSync);

            if (dialogResult == DialogResult.OK)
            {
                ConfigMail.Save();
                ConfigCaptcha.Save();
            }
        }

internal void CleanupTimer_Tick()
        {
            // Stop any pending timers, we'll restart the timer if there's anything left to process after cleanup.
            //
            // With the scheme we're using it's possible we could end up with some redundant cleanup operations.
            // This is expected and fine.
            // 
            // An alternative would be to take a lock during the whole cleanup process. This isn't ideal because it
            // would result in threads executing ExpiryTimer_Tick as they would need to block on cleanup to figure out
            // whether we need to start the timer.
            StopCleanupTimer();

            if (!Monitor.TryEnter(_cleanupActiveLock))
            {
                // We don't want to run a concurrent cleanup cycle. This can happen if the cleanup cycle takes
                // a long time for some reason. Since we're running user code inside Dispose, it's definitely
                // possible.
                //
                // If we end up in that position, just make sure the timer gets started again. It should be cheap
                // to run a 'no-op' cleanup.
                StartCleanupTimer();
                return;
            }

            try
            {
                var initialCount = _expiredHandlers.Count;
                Log.CleanupCycleStart(_logger, initialCount);

                var stopwatch = ValueStopwatch.StartNew();

                var disposedCount = 0;
                for (var i = 0; i < initialCount; i++)
                {
                    // Since we're the only one removing from _expired, TryDequeue must always succeed.
                    _expiredHandlers.TryDequeue(out var entry);
                    Debug.replacedert(entry != null, "Entry was null, we should always get an entry back from TryDequeue");

                    if (entry.CanDispose)
                    {
                        try
                        {
                            entry.InnerHandler.Dispose();
                            entry.Scope?.Dispose();
                            disposedCount++;
                        }
                        catch (Exception ex)
                        {
                            Log.CleanupItemFailed(_logger, entry.Name, ex);
                        }
                    }
                    else
                    {
                        // If the entry is still live, put it back in the queue so we can process it 
                        // during the next cleanup cycle.
                        _expiredHandlers.Enqueue(entry);
                    }
                }

                Log.CleanupCycleEnd(_logger, stopwatch.GetElapsedTime(), disposedCount, _expiredHandlers.Count);
            }
            finally
            {
                Monitor.Exit(_cleanupActiveLock);
            }

            // We didn't totally empty the cleanup queue, try again later.
            if (_expiredHandlers.Count > 0)
            {
                StartCleanupTimer();
            }
        }

public static RemoteWebDriver Acquire(IDriverFactory driverFactory, object poolScopeObject = null)
        {
            if (driverFactory == null)
                throw new ArgumentNullException(nameof(driverFactory));

            ConcurrentBag<DriverEntry> entries = ResolveEntriesBag(poolScopeObject);

            Monitor.Enter(entries);

            try
            {
                DriverEntry entry = entries.FirstOrDefault(x => x.Alias == driverFactory.Alias && !x.IsAcquired);

                if (entry is null)
                {
                    Monitor.Exit(entries);

                    entry = CreateDriverEntry(driverFactory);
                    entry.IsAcquired = true;

                    entries.Add(entry);
                }
                else
                {
                    entry.IsAcquired = true;
                }

                return entry.Driver;
            }
            finally
            {
                if (Monitor.IsEntered(entries))
                    Monitor.Exit(entries);
            }
        }

public async Task Wait(CancellationToken cancellationToken)
        {
            var isCompleted = false;

            while (!isCompleted)
            {
                if (cancellationToken.IsCancellationRequested)
                    cancellationToken.ThrowIfCancellationRequested();

                Monitor.Enter(_sync);

                var timeStampMs = DateTime.Now.ToUnixTimeMs();
                var differenceMs = timeStampMs - _lastRequestTimeStampMs;

                if (differenceMs < _minDelayBetweenRequestMs)
                {
                    Monitor.Exit(_sync);

                    await Task.Delay((int)(_minDelayBetweenRequestMs - differenceMs), cancellationToken)
                        .ConfigureAwait(false);
                }
                else
                {
                    _lastRequestTimeStampMs = timeStampMs;
                    Monitor.Exit(_sync);

                    isCompleted = true;
                }
            }
        }

public void Stop()
        {
            //If already locked, probably will be flashed by other calls so don't wait indefinitely
            if (Monitor.TryEnter(_lockObject, 1000))
            {
                try
                {
                    Flush(FlushReason.Stop);
                }
                finally
                {
                    Monitor.Exit(_lockObject);
                }
            }
        }

private void OnTimer(object state)
        {
            //If already locked, simply skip
            if (Monitor.TryEnter(_lockObject))
            {
                try
                {
                    Flush(FlushReason.Timer);
                }
                finally
                {
                    Monitor.Exit(_lockObject);
                }
            }
        }

private void Flush(object state)
        {
            //Wait maximum half of the interval _interval * 1000/2
            if (Monitor.TryEnter(_flushTimer, _interval * 500))
            {
                try
                {
                    IDictionary<MetricKey, MetricValue> acreplacedulatedValues = null;
                    IDictionary<MetricKey, MetricValue> lastValues = null;
                    lock (this)
                    {
                        acreplacedulatedValues = _acreplacedulatedValues;
                        _acreplacedulatedValues = InitAcreplacedulatedValues();
                        lastValues = new Dictionary<MetricKey, MetricValue>(_lastValues);
                    }
                    OnFlush(acreplacedulatedValues, lastValues);
                }
                catch (Exception ex)
                {
                    _logger?.LogError($"Metrics sink flush error id {Id} exception: {ex.ToMinimized()}");
                }
                finally
                {
                    Monitor.Exit(_flushTimer);
                }
            }
        }

protected internal virtual void Update(bool updateChildren, bool hasParentChanged)
        {
            if (this.parent == null)
            {
                Monitor.Enter(_queuedForUpdate);
            }

            this.isParentNotified = false;

            // skip update if not needed
            if (!updateChildren && !this.needParentUpdate && !this.needChildUpdate && !hasParentChanged)
            {
                return;
            }

            // see if need to process everyone
            if (this.needParentUpdate || hasParentChanged)
            {
                // update transforms from parent
                UpdateFromParent();

                if (NodeUpdated != null)
                {
                    NodeUpdated(this);
                }
            }

            // see if we need to process all
            if (this.needChildUpdate || hasParentChanged)
            {
                // update all children
                foreach (var child in this.childNodes.Values)
                {
                    child.Update(true, true);
                }

                this.childrenToUpdate.Clear();
            }
            else
            {
                // just update selected children
                foreach (var child in this.childrenToUpdate.Values)
                {
                    child.Update(true, false);
                }

                // clear the list
                this.childrenToUpdate.Clear();
            }

            // reset the flag
            this.needChildUpdate = false;

            if (this.parent == null)
            {
                Monitor.Exit(_queuedForUpdate);
            }
        }

private void visitCore()
    {
      var now = App.TimeSource.UTCNow;
      var toDelete = new HashSet<T>(m_Comparer);


      var ttlSec =  TimeLimitSec;
      var maxCount = SizeLimit;

      var overage = 0;
      if (maxCount>0)
        overage = m_Data.Sum( d => d.m_ApproximateCount ) - maxCount;

      var overagePerBucket = overage / m_Data.Length; //equal distribution is replacedumed per getBucket()

      for(var i=0; i<m_Data.Length; i++)
      {
        var dict = m_Data[i];
        var mustLock = (now - dict.m_LastLock).TotalSeconds > MUST_LOCK_BUCKET_SEC;

        if (!mustLock)
        {
          if (!Monitor.TryEnter(dict)) continue;
        }
        else Monitor.Enter(dict);
        try
        {
          dict.m_LastLock = now;//lock taken now

          toDelete.Clear();

          if (ttlSec>0) //impose time limit
            dict.Where(kvp => ((now - kvp.Value).TotalSeconds > ttlSec))
                .ForEach( kvp => toDelete.Add(kvp.Key));

          //impose count limit
          if (overagePerBucket > toDelete.Count)
          {
            var timeSorted = dict.OrderBy(kvp => kvp.Value);//ascending = older first
            foreach(var item in timeSorted)
             if (overagePerBucket>toDelete.Count)
              toDelete.Add( item.Key );
             else
              break;
          }

          toDelete.ForEach( k => dict.Remove(k) );
          dict.m_ApproximateCount = dict.Count;
        }
        finally
        {
          Monitor.Exit(dict);
        }
      }
    }

public void visit(bool stopping)
    {
      var now = App.LocalizedTime;
      for (var i = 0; i < m_BucketCount; i++)
      {
        var bucket = m_Buckets[i];
        if (stopping || bucket.LastAcquire.AddMilliseconds(MUST_ACQUIRE_INTERVAL_MS) < now)
          lock (bucket) write(bucket);
        else
        {
          if (Monitor.TryEnter(bucket))
          {
            try
            {
              write(bucket);
            }
            finally
            {
              Monitor.Exit(bucket);
            }
          }
        }
      }//for
    }