* @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up
   * @return the number of elements transferred
   * @throws InterruptedException if interrupted while waiting
   * @since 28.0 (but only since 33.4.0 in the Android flavor)
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible // BlockingQueue
  public static <E> int drain(

    val list = mutableListOf<String>()
    logs.drainTo(list)
    return list
  }

  fun take(): String =
    logs.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for log message.")

  }

  @Test
  fun synchronousCallAccessors() {
    val ready = CountDownLatch(2)
    val waiting = CountDownLatch(1)
    client =
      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            try {
              ready.countDown()
              waiting.await()
            } catch (e: InterruptedException) {
              throw AssertionError()

    startsFirst.start()
    val endsFirst = buildRequestThread(secondRequest, secondResponseCode)
    endsFirst.start()
    endsFirst.join()
    // First response is still waiting.
    assertThat(firstResponseCode.get()).isEqualTo(0)
    // Second response is done.
    assertThat(secondResponseCode.get()).isEqualTo(200)
    latch.countDown()
    startsFirst.join()
    // And now it's done!

   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up
   * @return the number of elements transferred
   * @throws InterruptedException if interrupted while waiting
   * @since 33.4.0 (but since 28.0 in the JRE flavor)
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible // BlockingQueue

    long timeout = SECONDS.toNanos(60);

    Supplier<Boolean> supplier =
        new Supplier<Boolean>() {
          boolean isWaiting(Thread thread) {
            switch (thread.getState()) {
              case BLOCKED:
              case WAITING:
              case TIMED_WAITING:
                return true;
              default:
                return false;
            }
          }

                                waitingThreadNames.size(), threadName);
                    }
                    return false;
                }
                if (logger.isInfoEnabled()) {
                    logger.info("Cpu Load {}% is greater than {}%. {} waiting thread(s).", current, percent, waitingThreadNames.size());

Blocking APIs may be inefficient because you hold a thread idle while waiting on the network. Threads are expensive because they have both a memory overhead and a context-switching overhead.

#### Framed protocols

      // even check the guard. I don't think we care too much about this use case but it could lead
      // to a confusing error message.
      throw new TimeoutException("Timed out waiting for " + this + " to reach the RUNNING state.");
    }
  }

  @Override
  public final void awaitTerminated() {
    monitor.enterWhenUninterruptibly(isStopped);
    try {

  @Override
  protected void tearDown() throws Exception {

    // Make sure we have no waiting threads.
    latch.countDown();
  }

  /** Constructs a listenable future with a value available after the latch has counted down. */
  protected abstract <V> ListenableFuture<V> createListenableFuture(
      V value, @Nullable Exception except, CountDownLatch waitOn);

  /** Tests that the {@link Future#get()} method blocks until a value is available. */