/// <summary> /// Allow setting the clock interface to be used by the cache. /// </summary> /// <param name="clock">The clock interface that will be used to determine timestamps.</param> public void SetClock(IClock clock) { using (cacheLock.ReaderLock()) { Clock = clock ?? new DefaultClock(); } }
public bool exists(string key) { using (var lk = rwl.ReaderLock()) { return(data.exists(key)); } }
public async Task LoadTest() { var rwl = new AsyncReaderWriterLock(); var readKeys = new List <IDisposable>(); for (int i = 0; i != 1000; ++i) { readKeys.Add(rwl.ReaderLock()); } var writeTask = Task.Run(() => { rwl.WriterLock().Dispose(); }); var readTasks = new List <Task>(); for (int i = 0; i != 100; ++i) { readTasks.Add(Task.Run(() => rwl.ReaderLock().Dispose())); } await Task.Delay(1000); foreach (var readKey in readKeys) { readKey.Dispose(); } await writeTask; foreach (var readTask in readTasks) { await readTask; } }
public async Task LoadTest() { AsyncReaderWriterLock rwl = new AsyncReaderWriterLock(); List <IDisposable> readKeys = new List <IDisposable>(); for (int i = 0; i != 1000; ++i) { readKeys.Add(rwl.ReaderLock()); } Task writeTask = Task.Run(() => rwl.WriterLock().Dispose()); List <Task> readTasks = new List <Task>(); for (int i = 0; i != 100; ++i) { readTasks.Add(Task.Run(() => rwl.ReaderLock().Dispose())); } await Task.Delay(1000).ConfigureAwait(false); foreach (IDisposable readKey in readKeys) { readKey.Dispose(); } await writeTask; foreach (Task readTask in readTasks) { await readTask; } }
private void DeleteIfNeeded(StringSegment databaseName, Task <DocumentDatabase> database) { database.ContinueWith(t => { // This is in case when an deletion request was issued prior to the actual loading of the database. try { using (_disposing.ReaderLock(_serverStore.ServerShutdown)) { if (_serverStore.ServerShutdown.IsCancellationRequested) { return; } using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context)) using (context.OpenReadTransaction()) using (var rawRecord = _serverStore.Cluster.ReadRawDatabaseRecord(context, databaseName.Value)) { if (rawRecord == null) { return; } ShouldDeleteDatabase(context, databaseName.Value, rawRecord); } } } catch { // nothing we can do here } }); }
/// <summary> /// Set the clock that will be used by the cache to determine when an etry expires. /// </summary> /// <param name="clock">The clock interface that will be used to determine timestamps.</param> public void SetClock(IClock?clock) { using (cacheLock.ReaderLock()) { Clock = clock ?? new SystemClock(); } }
public void DeleteIfNeeded(StringSegment databaseName, bool fromReplication = false) { try { using (_disposing.ReaderLock(_serverStore.ServerShutdown)) { if (_serverStore.ServerShutdown.IsCancellationRequested) { return; } using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context)) using (context.OpenReadTransaction()) using (var rawRecord = _serverStore.Cluster.ReadRawDatabaseRecord(context, databaseName.Value)) { if (rawRecord == null) { return; } ShouldDeleteDatabase(context, databaseName.Value, rawRecord, fromReplication); } } } catch { // nothing we can do here } }
protected override void InternalExport(out Entry[] heap, out int count) { using (myLock.ReaderLock()) { count = this.Count; heap = (Entry[])this.heap.Clone(); } }
public T this[int index] { get { using (Lock.ReaderLock()) { return(BackingCollection[index]); } } set { using (Lock.WriterLock()) { BackingCollection[index] = value; } } }
public bool Contains(T item) { using (_lock.ReaderLock()) { return(_list.Contains(item)); } }
public async Task ReadLock_WriteLockCanceled_TakesLock() { var rwl = new AsyncReaderWriterLock(); var readKey = rwl.ReaderLock(); var cts = new CancellationTokenSource(); var writerLockReady = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously); var writerLockTask = Task.Run(async() => { var writeKeyTask = rwl.WriterLockAsync(cts.Token); writerLockReady.SetResult(null); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => writeKeyTask); }); await writerLockReady.Task; var readerLockReady = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously); var readerLockTask = Task.Run(async() => { var readKeyTask = rwl.ReaderLockAsync(); readerLockReady.SetResult(null); await readKeyTask; }); await readerLockReady.Task; cts.Cancel(); await readerLockTask; }
/// <summary> /// check a request for rate limit /// </summary> /// <param name="request">a request</param> /// <returns>the stream of check result</returns> public AlgorithmCheckResult Check(object request) { if (_updatable) { using (var l = _mutex.ReaderLock()) { var originalRuleChecks = CheckAllRules(request); var ruleCheckResults = new List <RuleCheckResult>(); foreach (var result in originalRuleChecks) { ruleCheckResults.Add(result); } return(new AlgorithmCheckResult(ruleCheckResults)); } } else { var originalRuleChecks = CheckAllRules(request); var ruleCheckResults = new List <RuleCheckResult>(); foreach (var result in originalRuleChecks) { ruleCheckResults.Add(result); } return(new AlgorithmCheckResult(ruleCheckResults)); } }
internal static bool ContainsWithLock <T>(this ICollection <T> collection, T item, AsyncReaderWriterLock rwLock) { using (rwLock.ReaderLock()) { return(collection.Contains(item)); } }
public Node <T> this[int index] { get { using (_rwLock.ReaderLock()) { return(_steps[index]); } } set //TODO: to internal or remove { using (_rwLock.WriterLock()) { _steps.Insert(index, value); } } }
protected IEnumerable <StreamingData <EXTRA> > Where(Func <StreamingData <EXTRA>, bool> subject) { IEnumerable <StreamingData <EXTRA> > result = null; try { using (locker.ReaderLock()) { result = this.streams.Where(subject).ToArray(); } } catch (ApplicationException ex) { ErrorCode.LockFailedError.Throw(ex); } return(result); }
public TCell this[Node <T> a, Node <T> b] { get { using (_rwDataLock.ReaderLock()) { return(_rawArray[_indexToNodeMap.IndexOf(a), _indexToNodeMap.IndexOf(b)]); } } set { _checkMap(a, b); using (_rwDataLock.WriterLock()) { _rawArray[_indexToNodeMap.IndexOf(a), _indexToNodeMap.IndexOf(b)] = value; } } }
internal ConcurrentEnumerator(ICollection <T> collection, AsyncReaderWriterLock rwLock) { if ((collection == null) || (rwLock == null)) { throw new ArgumentNullException(nameof(collection) + " || " + nameof(rwLock)); } Lock = rwLock.ReaderLock(); Enumerator = collection.GetEnumerator(); }
private bool Match(T item) { using (_lockFilters.ReaderLock()) { if (_filters == null) { return(true); } return(item != null && _filters.Where(filter => filter.Expression != null).All(filter => filter.Expression(item))); } }
public static string HexiClientsToString(object addresses, AsyncReaderWriterLock locker) { if (addresses == null) { return(""); } using (locker.ReaderLock()) { var addr = (List <HexiUdpClient>)addresses; return(String.Join(", ", addr)); } }
bool IList.Contains(object value) { using (_lock.ReaderLock()) { return(((IList)_list).Contains(value)); } }
private void _checkMap(params Node <T>[] nodes) { using (_rwMapLock.ReaderLock()) { foreach (var node in nodes) { if (!_indexToNodeMap.Contains(node)) { _indexToNodeMap.Add(node); } } } }
public IDisposable EnsureNotDisposed() { IDisposable disposable = null; try { disposable = _lock.ReaderLock(_cts.Token); } catch { // ignore } if (disposable == null || _cts.IsCancellationRequested) { disposable?.Dispose(); ThrowDisposed(); } return(disposable); }
public void PurgeUnusedStreams() { var camsToKill = new List <int>(); using (lck.ReaderLock()) { foreach (int cameraId in processes.Keys) { accessTimes.TryGetValue(cameraId, out DateTime lastAccessTime); DateTime threshold = lastAccessTime.Add(oldStreamThreshold); if (DateTime.Now > threshold) { camsToKill.Add(cameraId); } } } if (camsToKill.Count > 0) { log.LogInformation("Purging {count} unused camera streams", camsToKill.Count); using (lck.WriterLock()) { foreach (int cameraId in camsToKill) { if (processes.TryGetValue(cameraId, out Process process)) { log.LogDebug("Purging {cameraId} camera stream", cameraId); process.Kill(); } processes.Remove(cameraId); accessTimes.Remove(cameraId, out _); } } } }
public bool Get <TValue>(TKey key, out TValue value) { bool entryFound; using (var @lock = cacheLock.ReaderLock()) { entryFound = cache.TryGetValue(key, out CacheEntry entry); if (entryFound && entry.Timestamp + TimeSpan.FromSeconds(CacheExpirationSeconds) > DateTime.Now) { value = (TValue)entry.Value; return(true); } }; if (entryFound) { // cache expired using var wLock = cacheLock.WriterLock(); cache.Remove(key); } value = default; return(false); }
public async static Task <int> ReadFirstItem() { using (await _lock.ReaderLock()) { return(_commonData.First()); } }
public IEnumerator <TItem> GetEnumerator() => new ConcurrentEnumerator <TItem>(Collection, Lock.ReaderLock());
public override void Reading(Action action) { AssertIsAlive(); using (_sync.ReaderLock()) action(); }
public bool Contains(T item) { using (Lock.ReaderLock()) { return(HashSet.Contains(item)); } }
protected override int?Execute(CommandExecutionToken <SQLiteCommand, SQLiteParameter> executionToken, CommandImplementation <SQLiteCommand> implementation, object state) { if (executionToken == null) { throw new ArgumentNullException("executionToken", "executionToken is null."); } if (implementation == null) { throw new ArgumentNullException("implementation", "implementation is null."); } var mode = DisableLocks ? LockType.None : (executionToken as SQLiteCommandExecutionToken)?.LockType ?? LockType.Write; var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); IDisposable lockToken = null; try { switch (mode) { case LockType.Read: lockToken = SyncLock.ReaderLock(); break; case LockType.Write: lockToken = SyncLock.WriterLock(); break; } using (var con = CreateConnection()) { using (var cmd = new SQLiteCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) { cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; } cmd.CommandText = executionToken.CommandText; //TODO: add potential check for this type. cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) { cmd.Parameters.Add(param); } executionToken.ApplyCommandOverrides(cmd); var rows = implementation(cmd); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } finally { if (lockToken != null) { lockToken.Dispose(); } } }
/// <summary> /// Access the machine model for read operations only /// </summary> /// <returns>Disposable lock object to be used with a using directive</returns> public static IDisposable AccessReadOnly() { return(new LockWrapper(_readWriteLock.ReaderLock(Program.CancellationToken), false)); }