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;
}
