Here are the examples of the csharp api System.Threading.Monitor.Exit(object) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
802 Examples
19
Source : Lock.cs
with MIT License
from 0x0ade
with MIT License
from 0x0ade
protected virtual void Dispose(bool disposing) {
if (disposing)
Monitor.Exit(m_pObject);
}
19
Source : CallBinder.cs
with MIT License
from 71
with MIT License
from 71
public void Dispose()
{
inContext = false;
invocationSymbol = null;
statementSymbol = null;
expressionSyntax = null;
statementSyntax = null;
callerInfo = null;
callerSymbol = null;
methodInfo = null;
methodSymbol = null;
Monitor.Exit(syncObject);
}
19
Source : GameFix.cs
with Apache License 2.0
from AantCoder
with Apache License 2.0
from AantCoder
[HarmonyPostfix]
public static void Postfix()
{
Monitor.Exit(SuncObj);
}
19
Source : GameFix.cs
with Apache License 2.0
from AantCoder
with Apache License 2.0
from AantCoder
[HarmonyPostfix]
public static void Postfix()
{
Monitor.Exit(ThingOwnerUtility_GetAllThingsRecursively_Patch.SuncObj);
}
19
Source : PXColorizerTaggerProvider.cs
with GNU General Public License v3.0
from Acumatica
with GNU General Public License v3.0
from Acumatica
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);
}
}
}
19
Source : VideoSource.cs
with MIT License
from adamfisher
with MIT License
from adamfisher
protected void OnLoadingStarted()
{
var obj = _syncHandle;
var lockTaken = false;
try
{
Monitor.Enter(obj, ref lockTaken);
CancellationTokenSource = new CancellationTokenSource();
}
finally
{
if (lockTaken)
Monitor.Exit(obj);
}
}
19
Source : VideoSource.cs
with MIT License
from adamfisher
with MIT License
from adamfisher
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);
}
}
19
Source : NamedLock.cs
with MIT License
from Adoxio
with MIT License
from Adoxio
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);
}
}
}
}
19
Source : NamedLock.cs
with MIT License
from Adoxio
with MIT License
from Adoxio
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);
}
19
Source : RedisProxy.Core.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
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);
}
}
19
Source : RedisProxy.Core.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
public void Dispose()
{
if (connect == null)
return;
Monitor.Enter(LockObj);
try
{
connect.Close();
connect.Dispose();
}
finally
{
Monitor.Exit(LockObj);
}
}
19
Source : RedisProxy.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
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);
}
}
19
Source : RedisProxy.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
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);
}
}
19
Source : MutexScope.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
protected override void OnDispose()
{
Monitor.Exit(_lockObject);
}
19
Source : StackExchangeRedis.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
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);
}
}
19
Source : WSSocket.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
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();
}
19
Source : OnceScope.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
protected override void OnDispose()
{
Monitor.Exit(_lockObj);
_closeAction?.Invoke();
}
19
Source : BaseShimHandler.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
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);
}
}
19
Source : BaseShimHandler.cs
with Mozilla Public License 2.0
from agebullhu
with Mozilla Public License 2.0
from agebullhu
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);
}
}
19
Source : KeyRingProvider.cs
with Apache License 2.0
from Aguafrommars
with Apache License 2.0
from Aguafrommars
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);
}
}
}
19
Source : TimedBlockingExecutor.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
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;
}
19
Source : BlockingLambdaSubscriber.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
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;
}
}
19
Source : BlockingLambdaSubscriber.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
void Unblock()
{
if (Interlocked.Increment(ref wip) == 1)
{
Monitor.Enter(this);
Monitor.Pulse(this);
Monitor.Exit(this);
}
}
19
Source : BlockingEnumeratorSubscriber.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
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;
}
19
Source : BlockingSubscriber.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
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);
}
}
19
Source : BlockingQueueConsumer.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
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;
}
19
Source : BlockingQueueConsumer.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
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;
}
}
}
}
19
Source : TimedBlockingExecutor.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
public void Dispose()
{
if (!Volatile.Read(ref shutdown))
{
Volatile.Write(ref shutdown, true);
Monitor.Enter(this);
Monitor.Pulse(this);
Monitor.Exit(this);
}
}
19
Source : TimedBlockingExecutor.cs
with Apache License 2.0
from akarnokd
with Apache License 2.0
from akarnokd
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);
}
}
}
}
}
19
Source : MonoProtection.cs
with Apache License 2.0
from allenai
with Apache License 2.0
from allenai
public void Dispose()
{
if (this.lockObject is object)
{
Monitor.Exit(this.lockObject);
}
}
19
Source : SQLiteAsync.cs
with GNU General Public License v3.0
from andysal
with GNU General Public License v3.0
from andysal
public void Dispose ()
{
Monitor.Exit (_lockPoint);
}
19
Source : DownloaderViewModel.cs
with GNU General Public License v3.0
from antikmozib
with GNU General Public License v3.0
from antikmozib
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);
}
}
19
Source : DownloaderViewModel.cs
with GNU General Public License v3.0
from antikmozib
with GNU General Public License v3.0
from antikmozib
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);
}
}
19
Source : DownloaderViewModel.cs
with GNU General Public License v3.0
from antikmozib
with GNU General Public License v3.0
from antikmozib
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);
}
}
19
Source : DownloaderViewModel.cs
with GNU General Public License v3.0
from antikmozib
with GNU General Public License v3.0
from antikmozib
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();
}
19
Source : LocalDatabaseContext.cs
with MIT License
from AntonyCorbett
with MIT License
from AntonyCorbett
public void Dispose()
{
Db.Dispose();
Monitor.Exit(Locker);
}
19
Source : Channel.cs
with Apache License 2.0
from apache
with Apache License 2.0
from apache
public void Disable()
{
Monitor.Enter(_lock);
_canSend = false;
Monitor.Exit(_lock);
}
19
Source : Channel.cs
with Apache License 2.0
from apache
with Apache License 2.0
from apache
public IDisposable Enter()
{
Monitor.Enter(_lock);
if (_canSend)
return this;
Monitor.Exit(_lock);
throw new OperationCanceledException();
}
19
Source : Channel.cs
with Apache License 2.0
from apache
with Apache License 2.0
from apache
public void Dispose()
=> Monitor.Exit(_lock);
19
Source : ParallelDeflateOutputStream.cs
with Apache License 2.0
from Appdynamics
with Apache License 2.0
from Appdynamics
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;
}
19
Source : Configuration.cs
with MIT License
from Ashesh3
with MIT License
from Ashesh3
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();
}
}
19
Source : DefaultHttpClientFactory.cs
with Apache License 2.0
from aspnet
with Apache License 2.0
from aspnet
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();
}
}
19
Source : DriverPool.cs
with Apache License 2.0
from atata-framework
with Apache License 2.0
from atata-framework
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);
}
}
19
Source : RequestLimitControl.cs
with GNU General Public License v3.0
from atomex-me
with GNU General Public License v3.0
from atomex-me
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;
}
}
}
19
Source : Batch.cs
with Apache License 2.0
from awslabs
with Apache License 2.0
from awslabs
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);
}
}
}
19
Source : Batch.cs
with Apache License 2.0
from awslabs
with Apache License 2.0
from awslabs
private void OnTimer(object state)
{
//If already locked, simply skip
if (Monitor.TryEnter(_lockObject))
{
try
{
Flush(FlushReason.Timer);
}
finally
{
Monitor.Exit(_lockObject);
}
}
}
19
Source : SimpleMetricsSink.cs
with Apache License 2.0
from awslabs
with Apache License 2.0
from awslabs
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);
}
}
}
19
Source : Node.cs
with GNU Lesser General Public License v2.1
from axiom3d
with GNU Lesser General Public License v2.1
from axiom3d
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);
}
}
19
Source : CappedSet.cs
with MIT License
from azist
with MIT License
from azist
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);
}
}
}
19
Source : ObjectStoreDaemon.cs
with MIT License
from azist
with MIT License
from azist
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
}
See More Examples