* specified array and the size of the specified collection.
   *
   * <p>If the collection fits in the specified array with room to spare (i.e., the array has more
   * elements than the collection), the element in the array immediately following the end of the
   * collection is set to {@code null}. This is useful in determining the length of the collection
   * <i>only</i> if the caller knows that the collection does not contain any null elements.
   *

  }

  /**
   * Returns a {@code ListenableFuture} which has an exception set immediately upon construction.
   *
   * <p>The returned {@code Future} can't be cancelled, and its {@code isDone()} method always
   * returns {@code true}. Calling {@code get()} will immediately throw the provided {@code
   * Throwable} wrapped in an {@code ExecutionException}.
   */

Esto incluye, por ejemplo:

* Notificaciones por email enviadas después de realizar una acción:
  * Como conectarse a un servidor de email y enviar un email tiende a ser "lento" (varios segundos), puedes devolver el response de inmediato y enviar la notificación por email en segundo plano.
* Procesamiento de datos:

            throw new SuggestIndexException(msg, e);
        }
    }

    /**
     * Adds a bad word.
     * @param badWord The bad word to add.
     * @param apply Whether to apply the change immediately.
     * @return The SuggestDeleteResponse.
     */
    public SuggestDeleteResponse addBadWord(final String badWord, final boolean apply) {
        final String normalized = normalizer.normalize(badWord, "");

  private val random: Random,
  private val pingIntervalMillis: Long,
  /**
   * For clients this is initially null, and will be assigned to the agreed-upon extensions. For
   * servers, it should be the agreed-upon extensions immediately.
   */
  private var extensions: WebSocketExtensions?,
  /** If compression is negotiated, outbound messages of this size and larger will be compressed. */
  private var minimumDeflateSize: Long,

        assertTrue(errorHandler.shouldFallbackToTcp(hardwareError), "Hardware errors should suggest TCP fallback");
        assertFalse(errorHandler.shouldFallbackToTcp(timeoutError), "Timeout errors should not immediately suggest TCP fallback");

        // Test error classification using public API
        assertNotNull(errorHandler, "Error handler should handle network errors");

        // Test fallback logic which is public

   *
   * <p>The returned executor is backed by the executor returned by {@link
   * MoreExecutors#newDirectExecutorService} and subject to the same constraints.
   *
   * <p>Although all tasks are immediately executed in the thread that submitted the task, this
   * {@code ExecutorService} imposes a small locking overhead on each task submission in order to
   * implement shutdown and termination behavior.
   *

        return headersQueue.removeFirst()
      }
      throw errorException ?: StreamResetException(errorCode!!)
    }
  }

  /**
   * Returns the trailers if they're immediately available.
   */
  @Throws(IOException::class)
  fun peekTrailers(): Headers? {
    withLock {
      if (source.finished && source.receiveBuffer.exhausted() && source.readBuffer.exhausted()) {

   *
   * <p>The returned executor is backed by the executor returned by {@link
   * MoreExecutors#newDirectExecutorService} and subject to the same constraints.
   *
   * <p>Although all tasks are immediately executed in the thread that submitted the task, this
   * {@code ExecutorService} imposes a small locking overhead on each task submission in order to
   * implement shutdown and termination behavior.
   *

      // elements already available (e.g. LinkedBlockingQueue#drainTo locks only once)
      added += q.drainTo(buffer, numElements - added);
      if (added < numElements) { // not enough elements immediately available; will have to poll
        E e = q.poll(deadline - System.nanoTime(), NANOSECONDS);
        if (e == null) {
          break; // we already waited enough, and there are no more elements in sight
        }