public async Task AsyncReaderWriterLock_ReaderThenReader() { // Verify that obtaining a reader lock does not block // another reader. var rwLock = new AsyncReaderWriterLock(); var haveLock = false; var inTask = false; var readLock = await rwLock.GetReadLockAsync(); Task.Run( async() => { inTask = true; using (await rwLock.GetReadLockAsync()) { haveLock = true; } }); Helper.WaitFor(() => inTask, defaultTimeout); await Task.Delay(taskWait); Assert.IsTrue(haveLock); readLock.Dispose(); Helper.WaitFor(() => haveLock, defaultTimeout); rwLock.Dispose(); }
public async Task AsyncReaderWriterLock_Basic() { var rwLock = (AsyncReaderWriterLock)null; var haveLock = false; // Verify that we can obtain a reader lock. rwLock = new AsyncReaderWriterLock(); haveLock = false; using (await rwLock.GetReadLockAsync()) { haveLock = true; } Assert.IsTrue(haveLock); rwLock.Dispose(); // Verify that we can obtain a writer lock. rwLock = new AsyncReaderWriterLock(); haveLock = false; using (await rwLock.GetWriteLockAsync()) { haveLock = true; } Assert.IsTrue(haveLock); rwLock.Dispose(); }
public async Task AsyncReaderWriterLock_ReaderThenWriter() { // Verify that obtaining a reader lock blocks a writer lock and then // that releasing the read lock, unblocks the writer. var rwLock = new AsyncReaderWriterLock(); var haveLock = false; var inTask = false; var readLock = await rwLock.GetReadLockAsync(); Task.Run( async() => { inTask = true; using (await rwLock.GetWriteLockAsync()) { haveLock = true; } }); Helper.WaitFor(() => inTask, defaultTimeout); await Task.Delay(taskWait); Assert.IsFalse(haveLock); readLock.Dispose(); Helper.WaitFor(() => haveLock, defaultTimeout); rwLock.Dispose(); }
public async Task WriterThenReader_Delay() { // Verify that obtaining a writer lock blocks a reader lock and then // that releasing the write lock, unblocks the reader. We'll add delay // to mix things up. var rwLock = new AsyncReaderWriterLock(); var haveLock = false; var inTask = false; var writeLock = await rwLock.GetWriteLockAsync(); var task = Task.Run( async() => { inTask = true; using (await rwLock.GetReadLockAsync()) { await Task.Delay(250); haveLock = true; } }); NeonHelper.WaitFor(() => inTask, defaultTimeout); await Task.Delay(taskWait); Assert.False(haveLock); writeLock.Dispose(); NeonHelper.WaitFor(() => haveLock, defaultTimeout); rwLock.Dispose(); }
public async Task ReaderThenReader_Delay() { // Verify that obtaining a reader lock does not block // another reader. We'll add delay to mix things up. var rwLock = new AsyncReaderWriterLock(); var haveLock = false; var inTask = false; var readLock = await rwLock.GetReadLockAsync(); var task = Task.Run( async() => { inTask = true; using (await rwLock.GetReadLockAsync()) { await Task.Delay(250); haveLock = true; } }); NeonHelper.WaitFor(() => inTask, defaultTimeout); await Task.Delay(taskWait); Assert.True(haveLock); readLock.Dispose(); NeonHelper.WaitFor(() => haveLock, defaultTimeout); rwLock.Dispose(); }
public void TestOperationAfterDisposeAsync() { var l = new AsyncReaderWriterLock(); l.Dispose(); Assert.ThrowsAsync <ObjectDisposedException>(() => l.ReadLockAsync()); Assert.ThrowsAsync <ObjectDisposedException>(() => l.WriteLockAsync()); }
/// <summary> /// Releases all resources associated with this audit trail. /// </summary> /// <param name="disposing">Indicates whether the <see cref="Dispose(bool)"/> has been called directly or from finalizer.</param> protected override void Dispose(bool disposing) { if (disposing) { syncRoot.Dispose(); commitEvent.Dispose(); } base.Dispose(disposing); }
public async Task AsyncReaderWriterLock_WriterThenMultipleWriters() { // Verify that obtaining a writer lock blocks multiple writers and then // that releasing the write lock, unblocks all of the other writers. const int writerCount = 10; var waitCount = 0; var acquireCount = 0; var rwLock = new AsyncReaderWriterLock(); var writeLock = await rwLock.GetWriteLockAsync(); for (int i = 0; i < writerCount; i++) { Task.Run( async() => { Interlocked.Increment(ref waitCount); //using (await rwLock.GetWriteLockAsync()) //{ // Interlocked.Increment(ref acquireCount); //} var testLock = await rwLock.GetWriteLockAsync(); Interlocked.Increment(ref acquireCount); testLock.Dispose(); }); } Helper.WaitFor(() => waitCount == writerCount, defaultTimeout); await Task.Delay(taskWait); Assert.AreEqual(0, acquireCount); writeLock.Dispose(); Helper.WaitFor(() => acquireCount == writerCount, defaultTimeout); rwLock.Dispose(); }
public async Task AsyncReaderWriterLock_WriterThenMultipleReaders_Delay() { // Verify that obtaining a writer lock blocks multiple readers and then // that releasing the write lock, unblocks all of the readers. We'll // add delay to mix things up. const int readerCount = 10; var waitCount = 0; var acquireCount = 0; var rwLock = new AsyncReaderWriterLock(); var writeLock = await rwLock.GetWriteLockAsync(); for (int i = 0; i < readerCount; i++) { Task.Run( async() => { Interlocked.Increment(ref waitCount); using (await rwLock.GetReadLockAsync()) { await Task.Delay(100); Interlocked.Increment(ref acquireCount); } }); } Helper.WaitFor(() => waitCount == readerCount, defaultTimeout); await Task.Delay(taskWait); Assert.AreEqual(0, acquireCount); writeLock.Dispose(); Helper.WaitFor(() => acquireCount == readerCount, defaultTimeout); rwLock.Dispose(); }
public async Task AsyncReaderWriterLock_Basic_Delay() { var rwLock = (AsyncReaderWriterLock)null; var haveLock = false; // Verify that we can obtain a reader lock. We'll add delay // to mix things up. rwLock = new AsyncReaderWriterLock(); haveLock = false; using (await rwLock.GetReadLockAsync()) { await Task.Delay(250); haveLock = true; } Assert.IsTrue(haveLock); rwLock.Dispose(); // Verify that we can obtain a writer lock. rwLock = new AsyncReaderWriterLock(); haveLock = false; using (await rwLock.GetWriteLockAsync()) { await Task.Delay(250); haveLock = true; } Assert.IsTrue(haveLock); rwLock.Dispose(); }
public virtual void Destroy() { // The cache is externally provided and may be shared. Destroying the cache is // not the responsibility of this class. _asyncReaderWriterLock.Dispose(); }