@Override public void release() { latchMap.setLatch( index, null ); super.release(); } }
public void unlock( int recordId ) { map.remove( recordId ).release(); } }
@Override public void run() { try { while ( !halted ) { try { pageCache.flushAndForce(); } catch ( Throwable e ) { error = e; break; } } } finally { halt.release(); } }
@Override public void disableLimit() { limitDisableCounter.getAndIncrement(); forceCheckPointStartLatch.release(); }
void submitIfRunnable( ThreadPoolManager pools ) { if ( compareAndSet( RUNNABLE, SUBMITTED ) ) { latestHandle = pools.submit( group, task ); handleRelease.release(); } }
@Override public void run() { assert backgroundThread == null : "A thread is already running " + backgroundThread; backgroundThread = Thread.currentThread(); startupLatch.release(); try { do { AsyncEvent events = STACK_UPDATER.getAndSet( this, END_SENTINEL ); process( events ); if ( stack == END_SENTINEL && !shutdown ) { LockSupport.park( this ); } } while ( !shutdown ); AsyncEvent events = STACK_UPDATER.getAndSet( this, SHUTDOWN_SENTINEL ); process( events ); } finally { backgroundThread = null; shutdownLatch.release(); } }
@Override public void cancel( boolean mayInterruptIfRunning ) { set( FAILED ); JobHandle handle = latestHandle; if ( handle != null ) { handle.cancel( mayInterruptIfRunning ); } for ( CancelListener cancelListener : cancelListeners ) { cancelListener.cancelled( mayInterruptIfRunning ); } // Release the handle to allow waitTermination() to observe the cancellation. handleRelease.release(); }
@Test void takeOrAwaitLatchMustNotLetUnrelatedLatchesConflictTooMuch() throws Exception { BinaryLatch latch = latches.takeOrAwaitLatch( 42 ); assertThat( latch, is( notNullValue() ) ); ExecutorService executor = Executors.newSingleThreadExecutor(); Future<BinaryLatch> future = executor.submit( () -> latches.takeOrAwaitLatch( 33 ) ); assertThat( future.get( 1, TimeUnit.SECONDS ), is( notNullValue() ) ); latch.release(); }
@Test void takeOrAwaitLatchMustReturnLatchIfAvailable() { BinaryLatch latch = latches.takeOrAwaitLatch( 0 ); assertThat( latch, is( notNullValue() ) ); latch.release(); }
@Override public void apply( Adder adder ) { super.apply( adder ); startLatch.release(); blockLatch.await(); } } ) );
@Test void releaseMustUnblockAwaiters() { assertTimeout( ofSeconds( 10 ), () -> { final BinaryLatch latch = new BinaryLatch(); Runnable awaiter = latch::await; int awaiters = 24; Future<?>[] futures = new Future<?>[awaiters]; for ( int i = 0; i < awaiters; i++ ) { futures[i] = executor.submit( awaiter ); } assertThrows( TimeoutException.class, () -> futures[0].get( 10, TimeUnit.MILLISECONDS ) ); latch.release(); for ( Future<?> future : futures ) { future.get(); } } ); }
@Test void releaseThenAwaitDoesNotBlock() { assertTimeout( ofSeconds( 3 ), () -> { BinaryLatch latch = new BinaryLatch(); latch.release(); latch.await(); } ); }
@Test( timeout = 10_000 ) public void scheduledTasksThatThrowsShouldStop() throws Exception { CentralJobScheduler scheduler = new CentralJobScheduler(); scheduler.init(); BinaryLatch triggerLatch = new BinaryLatch(); RuntimeException boom = new RuntimeException( "boom" ); AtomicInteger triggerCounter = new AtomicInteger(); Runnable job = () -> { triggerCounter.incrementAndGet(); triggerLatch.release(); throw boom; }; scheduler.scheduleRecurring( Group.INDEX_POPULATION, job, 1, TimeUnit.MILLISECONDS ); triggerLatch.await(); Thread.sleep( 50 ); assertThat( triggerCounter.get(), is( 1 ) ); }
blockLatch.release(); for ( JobHandle handle : handles )
blockLatch.release(); for ( FutureTask<Void> task : tasks )
lockerPause.release(); locker.get(); assertTrue( lockerDone.get() );
@Test public void longRunningTasksMustNotDelayExecutionOfOtherTasks() throws Exception { BinaryLatch latch = new BinaryLatch(); Runnable longRunning = latch::await; Runnable shortRunning = semaphore::release; scheduler.submit( Group.STORAGE_MAINTENANCE, longRunning, 100, 100 ); scheduler.submit( Group.STORAGE_MAINTENANCE, shortRunning, 100, 100 ); for ( int i = 0; i < 4; i++ ) { clock.forward( 100, TimeUnit.NANOSECONDS ); scheduler.tick(); assertSemaphoreAcquire(); } latch.release(); }