* this builder to sort entries by value.
   *
   * <p>Builder instances can be reused - it is safe to call {@link #buildOrThrow} multiple times to
   * build multiple bimaps in series. Each bimap is a superset of the bimaps created before it.
   *
   * @since 2.0
   */
  public static final class Builder<K, V> extends ImmutableMap.Builder<K, V> {
    /**

  /**
   * Clears fields that are no longer needed after this future has completed -- or at least all its
   * inputs have completed (more precisely, after {@link #handleAllCompleted()} has been called).
   * Often called multiple times (that is, both when the inputs complete and when the output
   * completes).
   *
   * <p>This is similar to our proposed {@code afterCommit} method but not quite the same. See the
   * description of CL 265462958.
   */

    public void testCloseIdempotent() {
        NtlmPasswordAuthenticator auth = new NtlmPasswordAuthenticator("user", "IdempotentPass123!");

        assertFalse(auth.isClosed());

        // Close multiple times
        auth.close();
        assertTrue(auth.isClosed());

        auth.close(); // Should not throw
        assertTrue(auth.isClosed());

        auth.close(); // Should still not throw

   * Object)} are even more convenient.
   *
   * <p>Builder instances can be reused - it is safe to call {@link #buildOrThrow} multiple times to
   * build multiple tables in series. Each table is a superset of the tables created before it.
   *
   * @since 11.0
   */
  @DoNotMock
  public static final class Builder<R, C, V> {

- dmitri.shuralyov.com/gpu/mtl: 666a987 → 28db891
- github.com/Azure/go-autorest/autorest: [v0.11.1 → v0.11.12](https://github.com/Azure/go-autorest/autorest/compare/v0.11.1...v0.11.12)
- github.com/NYTimes/gziphandler: [56545f4 → v1.1.1](https://github.com/NYTimes/gziphandler/compare/56545f4...v1.1.1)
- github.com/cilium/ebpf: [1c8d4c9 → v0.2.0](https://github.com/cilium/ebpf/compare/1c8d4c9...v0.2.0)

   *         .build();
   * }
   *
   * <p>Elements appear in the resulting list in the same order they were added to the builder.
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build
   * multiple lists in series. Each new list contains all the elements of the ones created before
   * it.
   *
   * @since 2.0
   */

     }
    ```

    You may also skip the retry when you’ve hit an application-defined attempt limit:

    ```kotlin
    if (response.responseCount >= 3) {
      return null // If we've failed 3 times, give up.
    }
    ```

    This above code relies on this `responseCount` extension val:

    ```kotlin
    val Response.responseCount: Int

        handleLeaseBreak(key, newState);
    });
    
    try {
        future.get(5, TimeUnit.SECONDS);  // 5 second timeout
    } catch (TimeoutException e) {
        // Force lease release if break handling times out
        releaseLease(key);
        log.warn("Lease break timeout for key: {}", key);
    }
}
```

### 10.2 Fallback to Oplocks
```java

     * Test transformer reusability
     */
    public void test_transformerReusability() {
        TestTransformer transformer = new TestTransformer("reusableTransformer");

        // Use transformer multiple times
        for (int i = 0; i < 10; i++) {
            ResponseData responseData = new ResponseData();
            responseData.setUrl("http://example.com/page" + i);

   *         .addCopies(Bean.RED, 8)
   *         .addCopies(Bean.BLACK_EYED, 10)
   *         .build();
   * }
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build
   * multiple multisets in series.
   *
   * @since 2.0
   */
  public static class Builder<E> extends ImmutableCollection.Builder<E> {
    final Multiset<E> contents;

    /**