/** * {@inheritDoc} */ @Override public int getAvailablePermissions() { return semaphore.availablePermits(); }
@Override public int getAvailableConcurrentCalls() { return semaphore.availablePermits(); } }
@Override public Number getSample() { return null == semaphore ? 0 : concurrency - semaphore.availablePermits(); } });
@Override public int getBalance() { return semaphore.availablePermits(); }
@Override public String toString() { return "<InitialImageFlowControl for GII to " + target + " with " + permits.availablePermits() + " available permits>"; }
/** * Size returns the sum of all sub-queue sizes, so it may be greater than * capacity. * Note: size provides no strict consistency, and should not be used to * control queue IO. */ @Override public int size() { return semaphore.availablePermits(); }
public int availablePermits() { return this.scanPermits.availablePermits(); }
/** * Get the number of permits available; guaranteed to be * {@code 0 <= availablePermits <= size}. * @return the number of permits available at the time of invocation. */ public int getAvailablePermits() { return queueingPermits.availablePermits(); }
public int getAvailableCount() { return semaphore.availablePermits(); }
@Monitor(name = METRIC_REPLICATION_PREFIX + "pendingJobRequests", description = "Number of worker threads awaiting job assignment", type = DataSourceType.GAUGE) public long getPendingJobRequests() { return singleItemWorkRequests.availablePermits() + batchWorkRequests.availablePermits(); }
LockHandleImpl(Connection conn, Statement stmt, ResultSet rs, String key, Semaphore derbySemaphore) { this.dbConn = conn; this.stmt = stmt; this.rs = rs; this.derbySemaphore = derbySemaphore; if(derbySemaphore != null) { //oterwise it may later release permit acquired by someone else assert derbySemaphore.availablePermits() == 0 : "Expected locked Semaphore"; } keys.add(key); } void addKey(String key) {
@Override public synchronized void resume() { if ( paused.getAndSet( false ) ) { assert acceptingRowsSemaphore.availablePermits() == 0; acceptingRowsSemaphore.release(); } }
@VisibleForTesting int getAvailablePermits() { return semaphore.availablePermits(); }
void refreshLimit() { int permissionsToRelease = this.rateLimiterConfig.get().getLimitForPeriod() - semaphore.availablePermits(); semaphore.release(permissionsToRelease); }
private void checkStopResourceManager() { if (!isRunning && runningQueriesSemaphore.availablePermits() == numRunners) { resourceManager.stop(); } } }
private void abort() { if (!aborted.getAndSet(true)) { incMessagesInFlight(-(maxPermits - permits.availablePermits())); // Just in case java has issues with semaphores rolling over, set this // to half Integer.MAX_VALUE rather to release all of the waiters permits.release(Integer.MAX_VALUE / 2); } }
@VisibleForTesting int getAcquiredPermits() { return config.getMaxConcurrentRequests() - semaphore.availablePermits(); } }
/** * Marks the source paused (if not already) and acquires the permit, which will cause acceptRows to block. */ @Override public synchronized void pause() { if ( !paused.getAndSet( true ) ) { try { assert acceptingRowsSemaphore.availablePermits() == 1; acceptingRowsSemaphore.acquire(); } catch ( InterruptedException e ) { logChannel.logError( getString( PKG, "BlockingQueueStream.PauseInterrupt" ) ); } } }
@Test @SuppressWarnings ( "unchecked" ) public void errorLoggedIfInterruptedInPause() throws InterruptedException { streamSource.acceptingRowsSemaphore = semaphore; when( semaphore.availablePermits() ).thenReturn( 1 ); streamSource.logChannel = logChannel; doThrow( new InterruptedException( "interrupt" ) ) .when( semaphore ).acquire(); streamSource.pause(); verify( logChannel ).logError( any() ); }
/** * {@inheritDoc} */ @Override public <T> FilterContext<T> filter(FilterContext<T> ctx) throws FilterException { try { if (logger.isDebugEnabled()) { logger.debug("Current Throttling Status {}", available.availablePermits()); } long startOfWait = System.currentTimeMillis(); attemptConcurrencyPermitAcquistion(ctx); attemptRateLimitedPermitAcquistion(ctx, startOfWait); } catch (InterruptedException e) { throw new FilterException(String.format("Interrupted Request %s with AsyncHandler %s", ctx.getRequest(), ctx.getAsyncHandler())); } return new FilterContext.FilterContextBuilder<>(ctx) .asyncHandler(ReleasePermitOnComplete.wrap(ctx.getAsyncHandler(), available)) .build(); }