@Override public Lock acquireNodeLock( long nodeId, LockType type ) { return lock( new LockedNode( nodeId ) ); }
@Override public Lock acquireRelationshipLock( long relationshipId, LockType type ) { return lock( new LockedRelationship( relationshipId ) ); }
private Lock lock( LockedEntity key ) { return new LockReference( key, acquire( key ) ); }
@Test public void acquireSharedLockAfterExclusiveLockStoppedOtherThread() throws Exception { AcquiredLock thisThreadsExclusiveLock = acquireExclusiveLockInThisThread(); LockAcquisition exclusiveLockAcquisition = acquireExclusiveLockInAnotherThread(); assertThreadIsWaitingForLock( exclusiveLockAcquisition ); exclusiveLockAcquisition.stop(); assertLockAcquisitionFailed( exclusiveLockAcquisition ); thisThreadsExclusiveLock.release(); LockAcquisition sharedLockAcquisition = acquireSharedLockInAnotherThread(); assertLockAcquisitionSucceeded( sharedLockAcquisition ); }
@Test public void sharedShouldWaitForExclusive() { // When clientA.acquireExclusive( LockTracer.NONE, NODE, 1L ); // Then shared locks should wait Future<Object> clientBLock = acquireShared( clientB, LockTracer.NONE, NODE, 1L ).callAndAssertWaiting(); // And when clientA.releaseExclusive( NODE, 1L ); // Then this should not block assertNotWaiting( clientB, clientBLock ); }
private int lockCount() { LockCountVisitor lockVisitor = new LockCountVisitor(); locks.accept( lockVisitor ); return lockVisitor.getLockCount(); } }
private AcquiredLock acquireExclusiveLockInThisThread() { client.acquireExclusive( TRACER, NODE, FIRST_NODE_ID ); assertLocksHeld( FIRST_NODE_ID ); return AcquiredLock.exclusive( client, NODE, FIRST_NODE_ID ); }
@Override protected void acquireLock( LockWorkerState state ) throws AcquireLockTimeoutException { state.doing( "+W " + resource + ", wait:" + wait ); state.client.acquireExclusive( LockTracer.NONE, NODE, resource ); state.done(); } }, wait );
public static Locks createLockManager( LocksFactory locksFactory, Config config, Clock clock ) { return locksFactory.newInstance( config, clock, ResourceTypes.values() ); }
private AcquiredLock acquireSharedLockInThisThread() { client.acquireShared( TRACER, NODE, FIRST_NODE_ID ); assertLocksHeld( FIRST_NODE_ID ); return AcquiredLock.shared( client, NODE, FIRST_NODE_ID ); }
@Override protected void acquireLock( LockWorkerState state ) { state.doing( "-W " + resource ); state.client.releaseExclusive( NODE, resource ); state.done(); } }, true );
@Override protected void acquireLock( LockWorkerState state ) { state.doing( "-R " + resource ); state.client.releaseShared( NODE, resource ); state.done(); } }, true );
@Override protected void acquireLock( LockWorkerState state ) throws AcquireLockTimeoutException { state.doing( "+R " + resource + ", wait:" + wait ); state.client.acquireShared( LockTracer.NONE, NODE, resource ); state.done(); } }, wait );
public Future<Object> callAndAssertNotWaiting() { Future<Object> run = call(); assertNotWaiting(client, run); return run; }
@Test public void acquireExclusiveLockAfterSharedLockStoppedOtherThread() throws Exception { AcquiredLock thisThreadsExclusiveLock = acquireExclusiveLockInThisThread(); LockAcquisition sharedLockAcquisition = acquireSharedLockInAnotherThread(); assertThreadIsWaitingForLock( sharedLockAcquisition ); sharedLockAcquisition.stop(); assertLockAcquisitionFailed( sharedLockAcquisition ); thisThreadsExclusiveLock.release(); LockAcquisition exclusiveLockAcquisition = acquireExclusiveLockInAnotherThread(); assertLockAcquisitionSucceeded( exclusiveLockAcquisition ); }
private static int lockCount( Locks locks ) { LockCountVisitor lockCountVisitor = new LockCountVisitor(); locks.accept( lockCountVisitor ); return lockCountVisitor.getLockCount(); }
@Test public void acquireSharedLockAfterSharedLockStoppedOtherThread() throws Exception { AcquiredLock thisThreadsExclusiveLock = acquireExclusiveLockInThisThread(); LockAcquisition sharedLockAcquisition1 = acquireSharedLockInAnotherThread(); assertThreadIsWaitingForLock( sharedLockAcquisition1 ); sharedLockAcquisition1.stop(); assertLockAcquisitionFailed( sharedLockAcquisition1 ); thisThreadsExclusiveLock.release(); LockAcquisition sharedLockAcquisition2 = acquireSharedLockInAnotherThread(); assertLockAcquisitionSucceeded( sharedLockAcquisition2 ); }
@Test public void acquireExclusiveLockAfterExclusiveLockStoppedOtherThread() throws Exception { AcquiredLock thisThreadsExclusiveLock = acquireExclusiveLockInThisThread(); LockAcquisition exclusiveLockAcquisition1 = acquireExclusiveLockInAnotherThread(); assertThreadIsWaitingForLock( exclusiveLockAcquisition1 ); exclusiveLockAcquisition1.stop(); assertLockAcquisitionFailed( exclusiveLockAcquisition1 ); thisThreadsExclusiveLock.release(); LockAcquisition exclusiveLockAcquisition2 = acquireExclusiveLockInAnotherThread(); assertLockAcquisitionSucceeded( exclusiveLockAcquisition2 ); }