private HttpStatusCode CancelCrossing(CrossingRequest cross) { m_crossLock.EnterUpgradeableReadLock(); try { if (m_crossings.ContainsKey(cross.uuid)) { m_crossLock.EnterWriteLock(); try { m_crossings.Remove(cross.uuid); return(HttpStatusCode.OK); } finally { m_crossLock.ExitWriteLock(); } } else { return(HttpStatusCode.NotFound); } } finally { m_crossLock.ExitUpgradeableReadLock(); } }
public bool CanAgentEnter(int id, Point3 pos, bool finalDestination) { _threadLock.EnterUpgradeableReadLock(); if (!_cells.TryGetValue(pos, out var cell) || !cell.IsWalkable) { _threadLock.ExitUpgradeableReadLock(); return(false); } if (cell.IsOccupied && cell.Occupied == id) { _threadLock.ExitUpgradeableReadLock(); return(true); } if (finalDestination && cell.IsOccupied && cell.Occupied != id) { _threadLock.ExitUpgradeableReadLock(); return(false); } if (cell.IsTempLocked && cell.TempLock != id) { _threadLock.ExitUpgradeableReadLock(); return(false); } _threadLock.EnterWriteLock(); cell.TempLock = id; SetCellCostInternal(cell); _threadLock.ExitWriteLock(); _threadLock.ExitUpgradeableReadLock(); return(true); }
internal PacketReceiver(string LocalAddress) : base (LocalAddress) { packetReceiver = new Queue(); tokenSource = new CancellationTokenSource(); readerWriterLock = new ReaderWriterLockSlim(); tokenSource.Token.Register(() => { // Clear on cancel packetReceiver.Clear(); }); var thReceiveQueue = Task.Factory.StartNew(() => { while (tokenSource.Token.IsCancellationRequested == false) { readerWriterLock.EnterUpgradeableReadLock(); if (packetReceiver.Count > 0) { readerWriterLock.EnterWriteLock(); byte[] data = (byte[])packetReceiver.Dequeue(); readerWriterLock.ExitWriteLock(); if (OnNewPacketReceived != null) OnNewPacketReceived(this, new NewPacketEventArgs(data)); } readerWriterLock.ExitUpgradeableReadLock(); } }); }
public void Dispose_Errors() { var v = new ReaderWriterLockSlim(); v.Dispose(); try { v.EnterUpgradeableReadLock(); Assert.Fail("1"); } catch (ObjectDisposedException) { } try { v.EnterReadLock(); Assert.Fail("2"); } catch (ObjectDisposedException) { } try { v.EnterWriteLock(); Assert.Fail("3"); } catch (ObjectDisposedException) { } }
public ReadLock(ReaderWriterLockSlim rwl, bool upgradeable = false) { this.rwl = rwl; this.upgradeable = upgradeable; if (upgradeable) rwl.EnterUpgradeableReadLock(); else rwl.EnterReadLock(); }
public static LockHandle UpgradeableRead(this ReaderWriterLockSlim self) { Check.Self(self); if (self.IsUpgradeableReadLockHeld || self.IsWriteLockHeld) { return(new LockHandle()); } self.EnterUpgradeableReadLock(); return(new LockHandle(self, LockHandle.LockType.UpgradeableRead)); }
public static void EnterExit() { using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim()) { Assert.False(rwls.IsReadLockHeld); rwls.EnterReadLock(); Assert.True(rwls.IsReadLockHeld); rwls.ExitReadLock(); Assert.False(rwls.IsReadLockHeld); Assert.False(rwls.IsUpgradeableReadLockHeld); rwls.EnterUpgradeableReadLock(); Assert.True(rwls.IsUpgradeableReadLockHeld); rwls.ExitUpgradeableReadLock(); Assert.False(rwls.IsUpgradeableReadLockHeld); Assert.False(rwls.IsWriteLockHeld); rwls.EnterWriteLock(); Assert.True(rwls.IsWriteLockHeld); rwls.ExitWriteLock(); Assert.False(rwls.IsWriteLockHeld); Assert.False(rwls.IsUpgradeableReadLockHeld); rwls.EnterUpgradeableReadLock(); Assert.False(rwls.IsWriteLockHeld); Assert.True(rwls.IsUpgradeableReadLockHeld); rwls.EnterWriteLock(); Assert.True(rwls.IsWriteLockHeld); rwls.ExitWriteLock(); Assert.False(rwls.IsWriteLockHeld); Assert.True(rwls.IsUpgradeableReadLockHeld); rwls.ExitUpgradeableReadLock(); Assert.False(rwls.IsUpgradeableReadLockHeld); Assert.True(rwls.TryEnterReadLock(0)); rwls.ExitReadLock(); Assert.True(rwls.TryEnterReadLock(Timeout.InfiniteTimeSpan)); rwls.ExitReadLock(); Assert.True(rwls.TryEnterUpgradeableReadLock(0)); rwls.ExitUpgradeableReadLock(); Assert.True(rwls.TryEnterUpgradeableReadLock(Timeout.InfiniteTimeSpan)); rwls.ExitUpgradeableReadLock(); Assert.True(rwls.TryEnterWriteLock(0)); rwls.ExitWriteLock(); Assert.True(rwls.TryEnterWriteLock(Timeout.InfiniteTimeSpan)); rwls.ExitWriteLock(); } }
public LockExtend(ReaderWriterLockSlim slim, LockMode mode) { _Slim = slim; this._Mode = mode; switch(mode) { case LockMode.Write: slim.EnterWriteLock(); break; case LockMode.Read: slim.EnterReadLock(); break; case LockMode.UpgradeableRead: slim.EnterUpgradeableReadLock(); break; } }
/// <summary> /// Initializes a new instance of the <see cref="ReadLock"/> class. /// </summary> /// <param name="readerWriterLockSlim">The reader writer lock slim.</param> public NestableUpgradableReadLock(ReaderWriterLockSlim readerWriterLockSlim) { // Keep track of the lock since we'll need it to release the lock. this.readerWriterLockSlim = readerWriterLockSlim; // If we already have a read or write lock, we don't do anything. if (readerWriterLockSlim.IsUpgradeableReadLockHeld || readerWriterLockSlim.IsWriteLockHeld) { lockAcquired = false; } else { readerWriterLockSlim.EnterUpgradeableReadLock(); lockAcquired = true; } }
public int RemoveAll(Predicate <TValue> predicate) { IList <TKey1> list = new List <TKey1>(); rwLock.EnterUpgradeableReadLock(); try { foreach (KeyValuePair <TKey1, TValue> kvp in Dictionary1) { if (predicate(kvp.Value)) { list.Add(kvp.Key); } } IList <TKey2> list2 = new List <TKey2>(list.Count); foreach (KeyValuePair <TKey2, TValue> kvp in Dictionary2) { if (predicate(kvp.Value)) { list2.Add(kvp.Key); } } rwLock.EnterWriteLock(); try { for (int i = 0; i < list.Count; i++) { Dictionary1.Remove(list[i]); } for (int i = 0; i < list2.Count; i++) { Dictionary2.Remove(list2[i]); } } finally { rwLock.ExitWriteLock(); } } finally { rwLock.ExitUpgradeableReadLock(); } return(list.Count); }
public int RemoveAll(Predicate <TValue> predicate) { IList <TKey1> list = new List <TKey1>(); rwLock.EnterUpgradeableReadLock(); try { foreach (var kvp in Dictionary1) { if (predicate(kvp.Value)) { list.Add(kvp.Key); } } IList <TKey2> list2 = new List <TKey2>(list.Count); foreach (var kvp in Dictionary2) { if (predicate(kvp.Value)) { list2.Add(kvp.Key); } } rwLock.EnterWriteLock(); try { foreach (var t in list) { Dictionary1.Remove(t); } foreach (var t in list2) { Dictionary2.Remove(t); } } finally { rwLock.ExitWriteLock(); } } finally { rwLock.ExitUpgradeableReadLock(); } return(list.Count); }
public SlimUpgradeableReadLockHolder(ReaderWriterLockSlim locker, bool waitForLock, bool wasLockAlreadyHelf) { this.locker = locker; if (wasLockAlreadyHelf) { lockAcquired = true; wasLockAlreadyHeld = true; return; } if(waitForLock) { locker.EnterUpgradeableReadLock(); lockAcquired = true; return; } lockAcquired = locker.TryEnterUpgradeableReadLock(0); }
/// <summary> /// Threadeds the atomic method async. /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <typeparam name="TList">The type of the list.</typeparam> /// <param name="rwLock">The reader writer lock.</param> /// <param name="list">The list.</param> /// <param name="key">The key.</param> /// <param name="method">The method.</param> /// <param name="contention">The contention.</param> /// <returns></returns> public static TValue ThreadedAtomicMethodAsync <TValue, TKey, TList>(this ReaderWriterLockSlim rwLock, TList list, TKey key, Func <TValue> method, Func <TValue> contention) where TList : IList <TKey> { rwLock.EnterUpgradeableReadLock(); try { if (!list.Contains(key)) { // set to running rwLock.EnterWriteLock(); try { if (list.Contains(key)) { return(contention()); } list.Add(key); } finally { rwLock.ExitWriteLock(); } // run queue TValue value; try { value = method(); } catch { list.Remove(key); throw; } // set to idle rwLock.EnterWriteLock(); try { //if (!list.Contains(key)) // return default(TValue); list.Remove(key); } finally { rwLock.ExitWriteLock(); } return(value); } } finally { rwLock.ExitUpgradeableReadLock(); } return(contention()); }
/// <summary> /// Threadeds the remove. /// </summary> /// <typeparam name="TValue">The type of the value.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <typeparam name="THash">The type of the hash.</typeparam> /// <param name="rwLock">The reader writer lock.</param> /// <param name="hash">The hash.</param> /// <param name="key">The key.</param> public static void ThreadedRemove <TValue, TKey, THash>(this ReaderWriterLockSlim rwLock, THash hash, TKey key) where THash : IDictionary <TKey, TValue> { rwLock.EnterUpgradeableReadLock(); try { if (hash.ContainsKey(key)) { rwLock.EnterWriteLock(); try { if (hash.ContainsKey(key)) { // remove hash.Remove(key); } } finally { rwLock.ExitWriteLock(); } } } finally { rwLock.ExitUpgradeableReadLock(); } }
/// <summary> /// Threadeds the get with create. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="rwLock">The reader writer lock.</param> /// <param name="value">The value.</param> /// <param name="builder">The builder.</param> /// <returns></returns> public static T ThreadedGetWithCreate <T>(this ReaderWriterLockSlim rwLock, ref T value, Func <T> builder) { rwLock.EnterUpgradeableReadLock(); try { if (value == null) { rwLock.EnterWriteLock(); try { if (value == null) { // create value = builder(); } } finally { rwLock.ExitWriteLock(); } } } finally { rwLock.ExitUpgradeableReadLock(); } return(value); }
public static void Dispose() { ReaderWriterLockSlim rwls; rwls = new ReaderWriterLockSlim(); rwls.Dispose(); Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterReadLock(0)); Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterUpgradeableReadLock(0)); Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterWriteLock(0)); rwls.Dispose(); for (int i = 0; i < 3; i++) { rwls = new ReaderWriterLockSlim(); switch (i) { case 0: rwls.EnterReadLock(); break; case 1: rwls.EnterUpgradeableReadLock(); break; case 2: rwls.EnterWriteLock(); break; } Assert.Throws<SynchronizationLockException>(() => rwls.Dispose()); } }
/// <summary> /// Initializes a new instance of the UpgradeableReadLock class to /// acquire an upgradeable read lock based on the specified /// ReaderWriterLockSlim object. /// </summary> public UpgradeableReadLock(ReaderWriterLockSlim rwlock) { this.rwlock = rwlock; rwlock.EnterUpgradeableReadLock(); }
public static void DontReleaseWaitingReadersWhenThereAreWaitingWriters() { using(var rwls = new ReaderWriterLockSlim()) { rwls.EnterUpgradeableReadLock(); rwls.EnterWriteLock(); // Typical order of execution: 0 // Add a waiting writer var threads = new Thread[2]; using(var beforeEnterWriteLock = new ManualResetEvent(false)) { var thread = new Thread(() => { beforeEnterWriteLock.Set(); rwls.EnterWriteLock(); // Typical order of execution: 3 rwls.ExitWriteLock(); }); thread.IsBackground = true; thread.Start(); threads[0] = thread; beforeEnterWriteLock.WaitOne(); } // Add a waiting reader using(var beforeEnterReadLock = new ManualResetEvent(false)) { var thread = new Thread(() => { beforeEnterReadLock.Set(); rwls.EnterReadLock(); // Typical order of execution: 4 rwls.ExitReadLock(); }); thread.IsBackground = true; thread.Start(); threads[1] = thread; beforeEnterReadLock.WaitOne(); } // Wait for the background threads to block waiting for their locks Thread.Sleep(1000); // Typical order of execution: 1 rwls.ExitWriteLock(); // At this point there is still one reader and one waiting writer, so the reader-writer lock should not try to // release any of the threads waiting for a lock // Typical order of execution: 2 rwls.ExitUpgradeableReadLock(); // At this point, the waiting writer should be released, and the waiting reader should not foreach(var thread in threads) thread.Join(); // Typical order of execution: 5 } }
private void EnterWriteLock(ReaderWriterLockSlim detectorLock) { detectorLock.EnterUpgradeableReadLock(); detectorLock.EnterWriteLock(); }
public void EnterWriteLock_After_ExitUpgradeableReadLock () { var v = new ReaderWriterLockSlim (); v.EnterUpgradeableReadLock (); Assert.IsTrue (v.TryEnterWriteLock (100)); v.ExitWriteLock (); v.ExitUpgradeableReadLock (); Assert.IsTrue (v.TryEnterWriteLock (100)); v.ExitWriteLock (); }
public void EnterUpgradeableReadLock_NoRecursionError () { var v = new ReaderWriterLockSlim (); v.EnterUpgradeableReadLock (); Assert.AreEqual (1, v.RecursiveUpgradeCount); try { v.EnterUpgradeableReadLock (); Assert.Fail ("2"); } catch (LockRecursionException) { } }
public void RecursiveWriteUpgradeTest() { ReaderWriterLockSlim rwlock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion); rwlock.EnterWriteLock(); Assert.IsTrue(rwlock.IsWriteLockHeld); rwlock.EnterUpgradeableReadLock(); Assert.IsTrue(rwlock.IsUpgradeableReadLockHeld); rwlock.ExitUpgradeableReadLock(); Assert.IsFalse(rwlock.IsUpgradeableReadLockHeld); Assert.IsTrue(rwlock.IsWriteLockHeld); rwlock.ExitWriteLock(); Assert.IsFalse(rwlock.IsWriteLockHeld); rwlock.EnterWriteLock(); Assert.IsTrue(rwlock.IsWriteLockHeld); }
public void RecursiveUpgradePropertiesTest () { var v = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion); v.EnterUpgradeableReadLock (); v.EnterUpgradeableReadLock (); Assert.AreEqual (true, v.IsUpgradeableReadLockHeld, "#1a"); Assert.AreEqual (false, v.IsReadLockHeld, "#11a"); Assert.AreEqual (0, v.CurrentReadCount, "#2a"); Assert.AreEqual (2, v.RecursiveUpgradeCount, "#3a"); bool upLock = false, rLock = false; int rCount = -1, rUCount = -1; Thread t = new Thread ((_) => { upLock = v.IsUpgradeableReadLockHeld; rLock = v.IsReadLockHeld; rCount = v.CurrentReadCount; rUCount = v.RecursiveUpgradeCount; }); t.Start (); t.Join (); Assert.AreEqual (false, upLock, "#1b"); Assert.AreEqual (false, rLock, "#11b"); Assert.AreEqual (0, rCount, "#2b"); Assert.AreEqual (0, rUCount, "#3b"); }
public UpgradableReadLock(ReaderWriterLockSlim locker) { _locker = locker; _locker.EnterUpgradeableReadLock(); }
/// <summary> /// Acquires a new upgradeable read lock. /// </summary> /// <param name="readWriteLock">The wrapped lock</param> public UpgradeableReadLock(ReaderWriterLockSlim readWriteLock) { _readWriteLock = readWriteLock; _readWriteLock.EnterUpgradeableReadLock(); }
private void Foo3() { var concurentDictionary = new Dictionary<int, int>(); var rwLockSlim = new ReaderWriterLockSlim(); var w = new ManualResetEvent(false); int timedCalled = 0; var threads = new List<Thread>(); int j; Lazy<int> lazy = new Lazy<int>(() => { Interlocked.Increment(ref timedCalled); return 1; }); for (int i = 0; i < Environment.ProcessorCount; i++) { threads.Add(new Thread(() => { w.WaitOne(); rwLockSlim.EnterUpgradeableReadLock(); try { if (!concurentDictionary.TryGetValue(1, out j)) { rwLockSlim.EnterWriteLock(); try { Interlocked.Increment(ref timedCalled); concurentDictionary[1] = 1; } finally { rwLockSlim.ExitWriteLock(); } } } finally { rwLockSlim.ExitUpgradeableReadLock(); } })); threads.Last().Start(); } w.Set();//release all threads to start at the same time Thread.Sleep(100); Console.WriteLine(timedCalled);// output is 1 }
public UpgradeableReadLockHelper( ReaderWriterLockSlim readerWriterLock ) { readerWriterLock.EnterUpgradeableReadLock(); this.readerWriterLock = readerWriterLock; }
public UsingUpgradeableReadLock(ReaderWriterLockSlim l) { parent = l; l.EnterUpgradeableReadLock (); }
public void RecursiveEnterExitUpgradableTest() { var v = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion); v.EnterUpgradeableReadLock(); v.EnterUpgradeableReadLock(); v.EnterUpgradeableReadLock(); Assert.IsTrue(v.IsUpgradeableReadLockHeld); Assert.AreEqual(3, v.RecursiveUpgradeCount); v.ExitUpgradeableReadLock(); Assert.IsTrue(v.IsUpgradeableReadLockHeld); Assert.AreEqual(2, v.RecursiveUpgradeCount); }
/// <summary> /// Initializes a new instance of the <see cref="UpgradableLock"/> class. /// </summary> /// <param name="readerWriterLockSlim">The reader writer lock slim.</param> public UpgradableLock(ReaderWriterLockSlim readerWriterLockSlim) { this.readerWriterLockSlim = readerWriterLockSlim; readerWriterLockSlim.EnterUpgradeableReadLock(); }
public static void DeadlockAvoidance() { using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim()) { rwls.EnterReadLock(); Assert.Throws<LockRecursionException>(() => rwls.EnterReadLock()); Assert.Throws<LockRecursionException>(() => rwls.EnterUpgradeableReadLock()); Assert.Throws<LockRecursionException>(() => rwls.EnterWriteLock()); rwls.ExitReadLock(); rwls.EnterUpgradeableReadLock(); rwls.EnterReadLock(); Assert.Throws<LockRecursionException>(() => rwls.EnterReadLock()); rwls.ExitReadLock(); Assert.Throws<LockRecursionException>(() => rwls.EnterUpgradeableReadLock()); rwls.EnterWriteLock(); Assert.Throws<LockRecursionException>(() => rwls.EnterWriteLock()); rwls.ExitWriteLock(); rwls.ExitUpgradeableReadLock(); rwls.EnterWriteLock(); Assert.Throws<LockRecursionException>(() => rwls.EnterReadLock()); Assert.Throws<LockRecursionException>(() => rwls.EnterUpgradeableReadLock()); Assert.Throws<LockRecursionException>(() => rwls.EnterWriteLock()); rwls.ExitWriteLock(); } using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion)) { rwls.EnterReadLock(); Assert.Throws<LockRecursionException>(() => rwls.EnterWriteLock()); rwls.EnterReadLock(); Assert.Throws<LockRecursionException>(() => rwls.EnterUpgradeableReadLock()); rwls.ExitReadLock(); rwls.ExitReadLock(); rwls.EnterUpgradeableReadLock(); rwls.EnterReadLock(); rwls.EnterUpgradeableReadLock(); rwls.ExitUpgradeableReadLock(); rwls.EnterReadLock(); rwls.ExitReadLock(); rwls.ExitReadLock(); rwls.EnterWriteLock(); rwls.EnterWriteLock(); rwls.ExitWriteLock(); rwls.ExitWriteLock(); rwls.ExitUpgradeableReadLock(); rwls.EnterWriteLock(); rwls.EnterReadLock(); rwls.ExitReadLock(); rwls.EnterUpgradeableReadLock(); rwls.ExitUpgradeableReadLock(); rwls.EnterWriteLock(); rwls.ExitWriteLock(); rwls.ExitWriteLock(); } }
public void Dispose_UpgradeableReadLock() { var rwl = new ReaderWriterLockSlim(); rwl.EnterUpgradeableReadLock(); try { rwl.Dispose(); Assert.Fail("1"); } catch (SynchronizationLockException) { } }
public static void InvalidExits(LockRecursionPolicy policy) { using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim(policy)) { Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock()); Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock()); Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock()); rwls.EnterReadLock(); Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock()); Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock()); rwls.ExitReadLock(); rwls.EnterUpgradeableReadLock(); Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock()); Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock()); rwls.ExitUpgradeableReadLock(); rwls.EnterWriteLock(); Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock()); Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock()); rwls.ExitWriteLock(); using (Barrier barrier = new Barrier(2)) { Task t = Task.Factory.StartNew(() => { rwls.EnterWriteLock(); barrier.SignalAndWait(); barrier.SignalAndWait(); rwls.ExitWriteLock(); }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); barrier.SignalAndWait(); Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock()); barrier.SignalAndWait(); t.GetAwaiter().GetResult(); } } }
public void EnterUpgradeableReadLock () { var v = new ReaderWriterLockSlim (); v.EnterUpgradeableReadLock (); Assert.IsTrue (v.IsUpgradeableReadLockHeld, "A"); Assert.AreEqual (0, v.RecursiveWriteCount, "A1"); Assert.AreEqual (0, v.RecursiveReadCount, "A2"); Assert.AreEqual (1, v.RecursiveUpgradeCount, "A3"); Assert.AreEqual (0, v.WaitingReadCount, "A4"); Assert.AreEqual (0, v.WaitingUpgradeCount, "A5"); Assert.AreEqual (0, v.WaitingWriteCount, "A6"); v.ExitUpgradeableReadLock (); v.EnterUpgradeableReadLock (); Assert.IsTrue (v.IsUpgradeableReadLockHeld, "B"); Assert.AreEqual (0, v.RecursiveWriteCount, "B1"); Assert.AreEqual (0, v.RecursiveReadCount, "B2"); Assert.AreEqual (1, v.RecursiveUpgradeCount, "B3"); Assert.AreEqual (0, v.WaitingReadCount, "B4"); Assert.AreEqual (0, v.WaitingUpgradeCount, "B5"); Assert.AreEqual (0, v.WaitingWriteCount, "B6"); v.EnterReadLock (); v.ExitUpgradeableReadLock (); Assert.IsTrue (v.IsReadLockHeld, "C"); Assert.AreEqual (0, v.RecursiveWriteCount, "C1"); Assert.AreEqual (1, v.RecursiveReadCount, "C2"); Assert.AreEqual (0, v.RecursiveUpgradeCount, "C3"); Assert.AreEqual (0, v.WaitingReadCount, "C4"); Assert.AreEqual (0, v.WaitingUpgradeCount, "C5"); Assert.AreEqual (0, v.WaitingWriteCount, "C6"); v.ExitReadLock (); }
public static void WriterToUpgradeableReaderChain() { using (AutoResetEvent are = new AutoResetEvent(false)) using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim()) { rwls.EnterWriteLock(); Task t = Task.Factory.StartNew(() => { Assert.False(rwls.TryEnterUpgradeableReadLock(TimeSpan.FromMilliseconds(10))); Task.Run(() => are.Set()); // ideally this won't fire until we've called EnterReadLock, but it's a benign race in that the test will succeed either way rwls.EnterUpgradeableReadLock(); rwls.ExitUpgradeableReadLock(); }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); are.WaitOne(); rwls.ExitWriteLock(); t.GetAwaiter().GetResult(); } }
public void RecursiveReadPlusUpgradeableLockTest () { var v = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion); try { v.EnterReadLock (); v.EnterUpgradeableReadLock (); Assert.Fail ("1"); } catch (LockRecursionException ex) { Assert.IsNotNull (ex, "#1"); } }
public SlimUpgradeableReadLock(ReaderWriterLockSlim lockSlim) { _lockSlim = lockSlim; _lockSlim.EnterUpgradeableReadLock(); }
public void EnterWriteLockWhileInUpgradeAndOtherWaiting () { var v = new ReaderWriterLockSlim (); var task2 = new Task(() => { v.EnterWriteLock(); v.ExitWriteLock(); }); var task1 = new Task(() => { v.EnterUpgradeableReadLock (); task2.Start (); Thread.Sleep (100); v.EnterWriteLock (); v.ExitWriteLock (); v.ExitUpgradeableReadLock (); }); task1.Start (); Assert.IsTrue (task1.Wait (500)); }
public UpgradeableReadLockHelper(ReaderWriterLockSlim readerWriterLock) { readerWriterLock.EnterUpgradeableReadLock(); this.readerWriterLock = readerWriterLock; }