list.add(new MockRunnable(countDownLatch), exec);
    assertEquals(3L, countDownLatch.getCount());

    list.execute();

    // Verify that all of the runnables execute in a reasonable amount of time.
    assertTrue(countDownLatch.await(1L, SECONDS));
  }

  public void testExecute_idempotent() {
    AtomicInteger runCalled = new AtomicInteger();
    list.add(runCalled::getAndIncrement, directExecutor());

    public void setAcquisitionTimeout(final long acquisitionTimeout) {
        this.acquisitionTimeout = acquisitionTimeout;
    }

    /**
     * Sets the group cache expiry time.
     * @param groupCacheExpiry The cache expiry time in seconds.
     */
    public void setGroupCacheExpiry(final long groupCacheExpiry) {
        this.groupCacheExpiry = groupCacheExpiry;
    }

    /**

 * version of this interface will be made to <i>extend</i> {@code java.util.function.Predicate}, so
 * that conversion will be necessary in only one direction. At that time, this interface will be
 * officially discouraged.
 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@GwtCompatible
public interface Predicate<T extends @Nullable Object> {
  /**

    return new MinimalIterable<>(asList(elements).iterator());
  }

  /**
   * Returns an iterable whose iterator returns the given elements in order. The elements are copied
   * out of the source collection at the time this method is called.
   */
  @SuppressWarnings("unchecked") // Es come in, Es go out
  public static <E extends @Nullable Object> MinimalIterable<E> from(Collection<E> elements) {

    // value seen so far
    while (cache.getUnchecked(nextRandomKey()) < maximumSize) {}

    requests.set(0);
    misses.set(0);
  }

  @Benchmark
  int time(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += cache.getUnchecked(nextRandomKey());
    }
    requests.addAndGet(reps);
    return dummy;
  }

  private int nextRandomKey() {

    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer numOfThread;

    /** The interval time between crawl requests in milliseconds (required, 0 to 2147483647). */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer intervalTime;

* **Easier onboarding**: New contributors have clear guidance on which spelling to use
* **Better searchability**: Finding code and documentation becomes more predictable
* **Reduced review friction**: Less time spent on spelling corrections during PR reviews
* **Professional appearance**: Consistent APIs and documentation appear more polished

 *
 * @author Isaac Shum
 * @since 1.0
 */
@GwtCompatible
public final class Callables {
  private Callables() {}

  /** Creates a {@code Callable} which immediately returns a preset value each time it is called. */
  public static <T extends @Nullable Object> Callable<T> returning(@ParametricNullness T value) {
    return () -> value;
  }

  /**
   * Creates an {@link AsyncCallable} from a {@link Callable}.
   *

### Cache the OpenAPI schema { #cache-the-openapi-schema }

You can use the property `.openapi_schema` as a "cache", to store your generated schema.

That way, your application won't have to generate the schema every time a user opens your API docs.

It will be generated only once, and then the same cached schema will be used for the next requests.

{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[13:14,25:26] *}

 * future version of {@code com.google.common.base.Supplier} will be made to <i>extend</i> {@code
 * java.util.function.Supplier}, making conversion code necessary only in one direction. At that
 * time, this interface will be officially discouraged.
 *
 * @author Harry Heymann
 * @since 2.0
 */
@GwtCompatible
public interface Supplier<T extends @Nullable Object> {
  /**