How to use

Semaphore

in

java.util.concurrent

@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
  if (unit == null) {
    throw new NullPointerException("unit");
  }
  if (inEventLoop()) {
    throw new IllegalStateException("cannot await termination of the current thread");
  }
  if (threadLock.tryAcquire(timeout, unit)) {
    threadLock.release();
  }
  return isTerminated();
}

 @Override
 public Semaphore get() {
  return new Semaphore(permits, false);
 }
});

public void addCall(final FSTRunnable toRun) throws InterruptedException {
  gateway.acquire();
  if (jobs[curIdx] == null) {
    jobs[curIdx] = toRun;
  } else {
    jobs[curIdx].sem.acquire();
    jobs[curIdx].sem.release();
    jobs[curIdx] = toRun;
  }
  toRun.sem = sems[curIdx];
  toRun.sem.acquire();
  OrderedRunnable ord = orderedRunnableCache[curIdx];
  ord.toRun = toRun;
  curIdx = (curIdx + 1) % threads;
  orderedPool.execute(ord);
  pool.execute(toRun);
}

public void waitForFinish() throws InterruptedException {
  final Semaphore sem = new Semaphore(0);
  orderedPool.execute(new Runnable() {
    @Override
    public void run() {
      sem.release();
    }
  });
  sem.acquire();
}

@Override public synchronized void resume() {
 if ( paused.getAndSet( false ) ) {
  assert acceptingRowsSemaphore.availablePermits() == 0;
  acceptingRowsSemaphore.release();
 }
}

@Override
public void onNext(Notification<T> args) {
  boolean wasNotAvailable = value.getAndSet(args) == null;
  if (wasNotAvailable) {
    notify.release();
  }
}

@Override
public void lockInterruptibly() throws InterruptedException {
 mAvailable.acquire(mPermits);
}

@Override
public boolean tryLock() {
 return mAvailable.tryAcquire(mPermits);
}

@AfterEach
private void refillSemaphore()
{
  // This ensures that no threads end up stuck
  semaphore.drainPermits();
  semaphore.release( Integer.MAX_VALUE );
}

@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 int getAvailablePermissions() {
  return semaphore.availablePermits();
}

@Override
public void onNext(Notification<T> args) {
  boolean wasNotAvailable = value.getAndSet(args) == null;
  if (wasNotAvailable) {
    notify.release();
  }
}

public void lock() {
 try {
  mLock.acquire();
 } catch (InterruptedException e) {
  throw new RuntimeException(e);
 }
}

public void feed(Object tuples) {
  Semaphore sem = new Semaphore(0);
  ((List) RegisteredGlobalState.getState(_semaphoreId)).add(sem);
  ((List) RegisteredGlobalState.getState(_id)).add(tuples);
  try {
    sem.acquire();
  } catch (InterruptedException e) {
    throw new RuntimeException(e);
  }
}

@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
 return mAvailable.tryAcquire(mPermits, time, unit);
}

void refreshLimit() {
  int permissionsToRelease = this.rateLimiterConfig.get().getLimitForPeriod() - semaphore.availablePermits();
  semaphore.release(permissionsToRelease);
}

  @Override
  public int getAvailableConcurrentCalls() {
    return semaphore.availablePermits();
  }
}

@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
  if (unit == null) {
    throw new NullPointerException("unit");
  }
  if (inEventLoop()) {
    throw new IllegalStateException("cannot await termination of the current thread");
  }
  if (threadLock.tryAcquire(timeout, unit)) {
    threadLock.release();
  }
  return isTerminated();
}

  @Override
  public void run() {
    sem.release();
  }
});

 @Override
 public Semaphore get() {
  return new Semaphore(permits, false);
 }
});