private int _marked; // synch helper in LockManager
internal RWLock(LockResource resource, RagManager ragManager, Clock clock, long lockAcquisitionTimeoutMillis)
{
this._resource = resource;
this._ragManager = ragManager;
this._clock = clock;
this._lockAcquisitionTimeoutMillis = lockAcquisitionTimeoutMillis;
}
public override bool TrySharedLock(ResourceType resourceType, long resourceId)
{
_stateHolder.incrementActiveClients(this);
try
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.map.primitive.MutableLongObjectMap<LockResource> localLocks = localShared(resourceType);
MutableLongObjectMap <LockResource> localLocks = LocalShared(resourceType);
LockResource resource = localLocks.get(resourceId);
if (resource != null)
{
resource.AcquireReference();
return(true);
}
else
{
resource = new LockResource(resourceType, resourceId);
if (_manager.tryReadLock(resource, _lockTransaction))
{
localLocks.put(resourceId, resource);
return(true);
}
else
{
return(false);
}
}
}
finally
{
_stateHolder.decrementActiveClients();
}
}
public override void AcquireShared(LockTracer tracer, ResourceType resourceType, params long[] resourceIds)
{
_stateHolder.incrementActiveClients(this);
try
{
MutableLongObjectMap <LockResource> localLocks = LocalShared(resourceType);
foreach (long resourceId in resourceIds)
{
LockResource resource = localLocks.get(resourceId);
if (resource != null)
{
resource.AcquireReference();
}
else
{
resource = new LockResource(resourceType, resourceId);
if (_manager.getReadLock(tracer, resource, _lockTransaction))
{
localLocks.put(resourceId, resource);
}
else
{
throw new LockClientStoppedException(this);
}
}
}
}
finally
{
_stateHolder.decrementActiveClients();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCleanupNotUsedLocks()
public virtual void ShouldCleanupNotUsedLocks()
{
// given
LockResource node = new LockResource(ResourceTypes.NODE, 1L);
LockTransaction lockTransaction = new LockTransaction();
LockManagerImpl lockManager = CreateLockManager();
lockManager.GetWriteLock(LockTracer.NONE, node, lockTransaction);
// expect
assertTrue(lockManager.TryReadLock(node, lockTransaction));
assertEquals(1, CountLocks(lockManager));
// and when
lockManager.ReleaseWriteLock(node, lockTransaction);
// expect to see one old reader
assertEquals(1, CountLocks(lockManager));
// and when
lockManager.ReleaseReadLock(node, lockTransaction);
// no more locks left
assertEquals(0, CountLocks(lockManager));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testLockCounters() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TestLockCounters()
{
RagManager ragManager = new RagManager();
LockResource resource = new LockResource(ResourceTypes.NODE, 1L);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, resource);
RWLock @lock = CreateRWLock(ragManager, resource);
LockTransaction lockTransaction = new LockTransaction();
LockTransaction anotherTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction writeTransaction = new LockTransaction();
LockTransaction writeTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch writerCompletedLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent writerCompletedLatch = new System.Threading.CountdownEvent(1);
@lock.Mark();
@lock.AcquireReadLock(LockTracer.NONE, lockTransaction);
@lock.Mark();
@lock.AcquireReadLock(LockTracer.NONE, anotherTransaction);
assertEquals(2, @lock.ReadCount);
assertEquals(0, @lock.WriteCount);
assertEquals(2, @lock.TxLockElementCount);
ThreadStart writer = CreateWriter(@lock, writeTransaction, writerCompletedLatch);
_executor.submit(writer);
WaitWaitingThreads(@lock, 1);
// check that all reader, writes, threads counters are correct
assertEquals(2, @lock.ReadCount);
assertEquals(0, @lock.WriteCount);
assertEquals(3, @lock.TxLockElementCount);
assertEquals(1, @lock.WaitingThreadsCount);
@lock.ReleaseReadLock(lockTransaction);
@lock.ReleaseReadLock(anotherTransaction);
writerCompletedLatch.await();
// test readers and waiting thread gone
assertEquals(0, @lock.ReadCount);
assertEquals(1, @lock.WriteCount);
assertEquals(1, @lock.TxLockElementCount);
assertEquals(0, @lock.WaitingThreadsCount);
@lock.ReleaseWriteLock(writeTransaction);
// check lock is clean in the end
assertEquals(0, @lock.TxLockElementCount);
assertEquals(0, @lock.WaitingThreadsCount);
assertEquals(0, @lock.ReadCount);
assertEquals(0, @lock.WriteCount);
}
private RWLock GetRWLockForAcquiring(LockResource resource, object tx)
{
AssertValidArguments(resource, tx);
lock ( _resourceLockMap )
{
RWLock @lock = _resourceLockMap.computeIfAbsent(resource, k => CreateLock(resource));
@lock.Mark();
return(@lock);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT_MILLIS) public void testLockRequestsTermination() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TestLockRequestsTermination()
{
// given
RagManager ragManager = new RagManager();
LockResource node1 = new LockResource(ResourceTypes.NODE, 1L);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, node1);
RWLock @lock = CreateRWLock(ragManager, node1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction mainTransaction = new LockTransaction();
LockTransaction mainTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction writerTransaction = new LockTransaction();
LockTransaction writerTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch writerCompletedLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent writerCompletedLatch = new System.Threading.CountdownEvent(1);
ThreadStart conflictingWriter = CreateFailedWriter(@lock, writerTransaction, writerCompletedLatch);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction readerTransaction = new LockTransaction();
LockTransaction readerTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch readerCompletedLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent readerCompletedLatch = new System.Threading.CountdownEvent(1);
ThreadStart reader = CreateFailedReader(@lock, readerTransaction, readerCompletedLatch);
// when
@lock.Mark();
assertTrue(@lock.AcquireWriteLock(LockTracer.NONE, mainTransaction));
_executor.submit(reader);
_executor.submit(conflictingWriter);
// wait waiters to come
WaitWaitingThreads(@lock, 2);
assertEquals(3, @lock.TxLockElementCount);
// when
@lock.TerminateLockRequestsForLockTransaction(readerTransaction);
@lock.TerminateLockRequestsForLockTransaction(writerTransaction);
readerCompletedLatch.await();
writerCompletedLatch.await();
// expect only main write lock counters and elements present
// all the rest should be cleaned up
assertEquals(0, @lock.WaitingThreadsCount);
assertEquals(0, @lock.ReadCount);
assertEquals(1, @lock.WriteCount);
assertEquals(1, @lock.TxLockElementCount);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT_MILLIS) public void testDeadlockDetection() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TestDeadlockDetection()
{
RagManager ragManager = new RagManager();
LockResource node1 = new LockResource(ResourceTypes.NODE, 1L);
LockResource node2 = new LockResource(ResourceTypes.NODE, 2L);
LockResource node3 = new LockResource(ResourceTypes.NODE, 3L);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lockNode1 = createRWLock(ragManager, node1);
RWLock lockNode1 = CreateRWLock(ragManager, node1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lockNode2 = createRWLock(ragManager, node2);
RWLock lockNode2 = CreateRWLock(ragManager, node2);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lockNode3 = createRWLock(ragManager, node3);
RWLock lockNode3 = CreateRWLock(ragManager, node3);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction client1Transaction = new LockTransaction();
LockTransaction client1Transaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction client2Transaction = new LockTransaction();
LockTransaction client2Transaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction client3Transaction = new LockTransaction();
LockTransaction client3Transaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch deadLockDetector = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent deadLockDetector = new System.Threading.CountdownEvent(1);
lockNode1.Mark();
lockNode1.AcquireWriteLock(LockTracer.NONE, client1Transaction);
lockNode2.Mark();
lockNode2.AcquireWriteLock(LockTracer.NONE, client2Transaction);
lockNode3.Mark();
lockNode3.AcquireWriteLock(LockTracer.NONE, client3Transaction);
ThreadStart readerLockNode2 = CreateReaderForDeadlock(lockNode3, client1Transaction, deadLockDetector);
ThreadStart readerLockNode3 = CreateReaderForDeadlock(lockNode1, client2Transaction, deadLockDetector);
ThreadStart readerLockNode1 = CreateReaderForDeadlock(lockNode2, client3Transaction, deadLockDetector);
_executor.execute(readerLockNode2);
_executor.execute(readerLockNode3);
_executor.execute(readerLockNode1);
// Deadlock should occur
assertTrue("Deadlock was detected as expected.", deadLockDetector.await(TEST_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
lockNode3.ReleaseWriteLock(client3Transaction);
lockNode2.ReleaseWriteLock(client2Transaction);
lockNode1.ReleaseWriteLock(client1Transaction);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public void accept(final org.neo4j.kernel.impl.locking.Locks_Visitor visitor)
public override void Accept(Org.Neo4j.Kernel.impl.locking.Locks_Visitor visitor)
{
_manager.accept(element =>
{
object resource = element.resource();
if (resource is LockResource)
{
LockResource lockResource = ( LockResource )resource;
visitor.Visit(lockResource.Type(), lockResource.ResourceId(), element.describe(), element.maxWaitTime(), System.identityHashCode(lockResource));
}
return(false);
});
}
/*
* In case if writer thread can't grab write lock now, it should be added to
* into a waiting list, wait till resource will be free and grab it.
*/
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT_MILLIS) public void testWaitingWriterLock() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TestWaitingWriterLock()
{
RagManager ragManager = new RagManager();
LockResource resource = new LockResource(ResourceTypes.NODE, 1L);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, resource);
RWLock @lock = CreateRWLock(ragManager, resource);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction lockTransaction = new LockTransaction();
LockTransaction lockTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction anotherTransaction = new LockTransaction();
LockTransaction anotherTransaction = new LockTransaction();
@lock.Mark();
@lock.AcquireReadLock(LockTracer.NONE, lockTransaction);
@lock.Mark();
@lock.AcquireReadLock(LockTracer.NONE, anotherTransaction);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch writerCompletedLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent writerCompletedLatch = new System.Threading.CountdownEvent(1);
ThreadStart writer = CreateWriter(@lock, lockTransaction, writerCompletedLatch);
// start writer that will be placed in a wait list
_executor.execute(writer);
// wait till writer will be added into a list of waiters
WaitWaitingThreads(@lock, 1);
assertEquals("No writers for now.", 0, @lock.WriteCount);
assertEquals(2, @lock.ReadCount);
// releasing read locks that will allow writer to grab the lock
@lock.ReleaseReadLock(lockTransaction);
@lock.ReleaseReadLock(anotherTransaction);
// wait till writer will have write lock
writerCompletedLatch.await();
assertEquals(1, @lock.WriteCount);
assertEquals(0, @lock.ReadCount);
// now releasing write lock
@lock.ReleaseWriteLock(lockTransaction);
assertEquals("Lock should not have any writers left.", 0, @lock.WriteCount);
assertEquals("No waiting threads left.", 0, @lock.WaitingThreadsCount);
assertEquals("No lock elements left.", 0, @lock.TxLockElementCount);
}
private bool ReEnter(LongObjectMap <LockResource> localLocks, long resourceId)
{
LockResource resource = localLocks.get(resourceId);
if (resource != null)
{
resource.AcquireReference();
return(true);
}
else
{
return(false);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotBePossibleReleaseNotExistingLock()
public virtual void ShouldNotBePossibleReleaseNotExistingLock()
{
// given
LockResource node1 = new LockResource(ResourceTypes.NODE, 1L);
LockTransaction lockTransaction = new LockTransaction();
LockManagerImpl lockManager = CreateLockManager();
// expect
ExpectedException.expect(typeof(LockNotFoundException));
ExpectedException.expectMessage("Lock not found for: ");
// when
lockManager.ReleaseReadLock(node1, lockTransaction);
}
public override bool Equals(object o)
{
if (this == o)
{
return(true);
}
if (o == null || this.GetType() != o.GetType())
{
return(false);
}
LockResource that = ( LockResource )o;
return(_resourceId == that._resourceId && _resourceType.Equals(that._resourceType));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReleaseNotAcquiredLocks()
public virtual void ShouldReleaseNotAcquiredLocks()
{
// given
LockResource node = new LockResource(ResourceTypes.NODE, 1L);
LockTransaction lockTransaction = new LockTransaction();
RWLock rwLock = Mockito.mock(typeof(RWLock));
LockManagerImpl lockManager = new MockedLockLockManager(this, new RagManager(), rwLock);
// expect
lockManager.TryReadLock(node, lockTransaction);
// during client close any of the attempts to get read/write lock can be scheduled as last one
// in that case lock will hot have marks, readers, writers anymore and optimistically created lock
// need to be removed from global map resource map
assertEquals(0, CountLocks(lockManager));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT_MILLIS) public void testWaitingReaderLock() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TestWaitingReaderLock()
{
RagManager ragManager = new RagManager();
LockResource resource = new LockResource(ResourceTypes.NODE, 1L);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, resource);
RWLock @lock = CreateRWLock(ragManager, resource);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction transaction = new LockTransaction();
LockTransaction transaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction readerTransaction = new LockTransaction();
LockTransaction readerTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch readerCompletedLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent readerCompletedLatch = new System.Threading.CountdownEvent(1);
@lock.Mark();
@lock.AcquireWriteLock(LockTracer.NONE, transaction);
ThreadStart reader = CreateReader(@lock, readerTransaction, readerCompletedLatch);
// start reader that should wait for writer to release write lock
_executor.execute(reader);
WaitWaitingThreads(@lock, 1);
assertEquals(1, @lock.WriteCount);
assertEquals("No readers for now", 0, @lock.ReadCount);
@lock.ReleaseWriteLock(transaction);
// wait till reader finish lock grab
readerCompletedLatch.await();
assertEquals(0, @lock.WriteCount);
assertEquals(1, @lock.ReadCount);
@lock.ReleaseReadLock(readerTransaction);
assertEquals("Lock should not have any readers left.", 0, @lock.ReadCount);
assertEquals("No waiting threads left.", 0, @lock.WaitingThreadsCount);
assertEquals("No lock elements left.", 0, @lock.TxLockElementCount);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAllowGetReadWriteLocks()
public virtual void ShouldAllowGetReadWriteLocks()
{
// given
LockResource node1 = new LockResource(ResourceTypes.NODE, 1L);
LockResource node2 = new LockResource(ResourceTypes.NODE, 2L);
LockTransaction lockTransaction = new LockTransaction();
LockManagerImpl lockManager = CreateLockManager();
// expect
assertTrue(lockManager.GetReadLock(LockTracer.NONE, node1, lockTransaction));
assertTrue(lockManager.GetReadLock(LockTracer.NONE, node2, lockTransaction));
assertTrue(lockManager.GetWriteLock(LockTracer.NONE, node2, lockTransaction));
lockManager.ReleaseReadLock(node1, lockTransaction);
lockManager.ReleaseReadLock(node2, lockTransaction);
lockManager.ReleaseWriteLock(node2, lockTransaction);
int lockCount = CountLocks(lockManager);
assertEquals(0, lockCount);
}
public override void ReleaseExclusive(ResourceType resourceType, params long[] resourceIds)
{
_stateHolder.incrementActiveClients(this);
try
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.map.primitive.MutableLongObjectMap<LockResource> localLocks = localExclusive(resourceType);
MutableLongObjectMap <LockResource> localLocks = LocalExclusive(resourceType);
foreach (long resourceId in resourceIds)
{
LockResource resource = localLocks.get(resourceId);
if (resource.ReleaseReference() == 0)
{
localLocks.remove(resourceId);
_manager.releaseWriteLock(new LockResource(resourceType, resourceId), _lockTransaction);
}
}
}
finally
{
_stateHolder.decrementActiveClients();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void assertReadLockDoesNotLeakMemory()
public virtual void AssertReadLockDoesNotLeakMemory()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RagManager ragManager = new RagManager();
RagManager ragManager = new RagManager();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockResource resource = new LockResource(org.neo4j.kernel.impl.locking.ResourceTypes.NODE, 0);
LockResource resource = new LockResource(ResourceTypes.NODE, 0);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, resource);
RWLock @lock = CreateRWLock(ragManager, resource);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.Transaction tx1 = mock(org.neo4j.graphdb.Transaction.class);
Transaction tx1 = mock(typeof(Transaction));
@lock.Mark();
@lock.AcquireReadLock(LockTracer.NONE, tx1);
@lock.Mark();
assertEquals(1, @lock.TxLockElementCount);
@lock.ReleaseReadLock(tx1);
assertEquals(0, @lock.TxLockElementCount);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @VisibleForTesting protected RWLock createLock(LockResource resource)
protected internal virtual RWLock CreateLock(LockResource resource)
{
return(new RWLock(resource, _ragManager, _clock, _lockAcquisitionTimeoutMillis));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT_MILLIS) public void testThreadRemovedFromWaitingListOnDeadlock() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TestThreadRemovedFromWaitingListOnDeadlock()
{
RagManager ragManager = Mockito.mock(typeof(RagManager));
LockResource resource = new LockResource(ResourceTypes.NODE, 1L);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, resource);
RWLock @lock = CreateRWLock(ragManager, resource);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction lockTransaction = new LockTransaction();
LockTransaction lockTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockTransaction anotherTransaction = new LockTransaction();
LockTransaction anotherTransaction = new LockTransaction();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch exceptionLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent exceptionLatch = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch completionLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent completionLatch = new System.Threading.CountdownEvent(1);
Mockito.doNothing().doAnswer(invocation =>
{
exceptionLatch.Signal();
throw new DeadlockDetectedException("Deadlock");
}).when(ragManager).checkWaitOn(@lock, lockTransaction);
@lock.Mark();
@lock.Mark();
@lock.AcquireReadLock(LockTracer.NONE, lockTransaction);
@lock.AcquireReadLock(LockTracer.NONE, anotherTransaction);
// writer will be added to a waiting list
// then spurious wake up will be simulated
// and deadlock will be detected
ThreadStart writer = () =>
{
try
{
@lock.Mark();
@lock.AcquireWriteLock(LockTracer.NONE, lockTransaction);
}
catch (DeadlockDetectedException)
{
// ignored
}
completionLatch.Signal();
};
_executor.execute(writer);
WaitWaitingThreads(@lock, 1);
// sending notify for all threads till our writer will not cause deadlock exception
do
{
//noinspection SynchronizationOnLocalVariableOrMethodParameter
lock ( @lock )
{
Monitor.PulseAll(@lock);
}
} while (exceptionLatch.CurrentCount == 1);
// waiting for writer to finish
completionLatch.await();
assertEquals("In case of deadlock caused by spurious wake up " + "thread should be removed from waiting list", 0, @lock.WaitingThreadsCount);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public boolean getWriteLock(org.neo4j.storageengine.api.lock.LockTracer tracer, LockResource resource, Object tx) throws org.neo4j.kernel.DeadlockDetectedException, org.neo4j.kernel.impl.transaction.IllegalResourceException
public virtual bool GetWriteLock(LockTracer tracer, LockResource resource, object tx)
{
return(UnusedResourceGuard(resource, tx, GetRWLockForAcquiring(resource, tx).acquireWriteLock(tracer, tx)));
}
protected internal override RWLock CreateLock(LockResource resource)
{
return(Lock);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public boolean tryWriteLock(LockResource resource, Object tx) throws org.neo4j.kernel.impl.transaction.IllegalResourceException
public virtual bool TryWriteLock(LockResource resource, object tx)
{
return(UnusedResourceGuard(resource, tx, GetRWLockForAcquiring(resource, tx).tryAcquireWriteLock(tx)));
}
private RWLock CreateRWLock(RagManager ragManager, LockResource resource)
{
return(new RWLock(resource, ragManager, Clocks.systemClock(), 0));
}