func (c *Connection) reconnected() {
	c.updateState(StateConnectionError)
	c.reconnects.Add(1)

	// Drain the outQueue, so any blocked messages can be sent.
	// We keep the queue, but start draining it, if it gets full.
	stopDraining := make(chan struct{})
	var wg sync.WaitGroup
	wg.Add(1)
	defer func() {
		close(stopDraining)
		wg.Wait()
	}()
	go func() {
		defer wg.Done()
		for {
			select {

    server.enqueue(
      MockResponse(body = "This gets leaked."),
    )
    client =
      clientTestRule
        .newClientBuilder()
        .connectionPool(ConnectionPool(0, 10, TimeUnit.MILLISECONDS))
        .build()
    val request = Request(server.url("/"))
    client.newCall(request).execute() // Ignore the response so it gets leaked then GC'd.
    awaitGarbageCollection()

This simplicity and flexibility allow doing things like using NoSQL databases as the main data storage system.

As it is very simple, it's relatively intuitive to learn, although the documentation gets somewhat technical at some points.

                  } else {
                    cache.refresh(key);
                    value = cache.get(key);
                  }
                  result.set(index, value);
                } catch (Throwable t) {
                  result.set(index, t);
                }
                gettersComplete.countDown();
              });
      thread.start();

        setValue(i, function.apply(key(i), value(i)));
      }
    }
  }

  @LazyInit private transient @Nullable Set<K> keySetView;

  @Override
  public Set<K> keySet() {
    return (keySetView == null) ? keySetView = createKeySet() : keySetView;
  }

  Set<K> createKeySet() {
    return new KeySetView();
  }

  @WeakOuter
  class KeySetView extends Maps.KeySet<K, V> {

TLS Termination Proxyとして使えるオプションには、以下のようなものがあります：

* Traefik（証明書の更新も対応）
* Caddy (証明書の更新も対応)
* Nginx
* HAProxy


## Let's Encrypt { #lets-encrypt }

Let's Encrypt以前は、これらの**HTTPS証明書**は信頼できる第三者によって販売されていました。

これらの証明書を取得するための手続きは面倒で、かなりの書類を必要とし、証明書はかなり高価なものでした。

しかしその後、**[Let's Encrypt](https://letsencrypt.org/)** が作られました。

	// TransitionTier name of transition storage class
	TransitionTier = "transition-tier"
)

// LifecycleSys - Bucket lifecycle subsystem.
type LifecycleSys struct{}

// Get - gets lifecycle config associated to a given bucket name.
func (sys *LifecycleSys) Get(bucketName string) (lc *lifecycle.Lifecycle, err error) {
	lc, _, err = globalBucketMetadataSys.GetLifecycleConfig(bucketName)
	return lc, err
}

        final String result = chatClient.testBuildAssistantHistoryContent(msg, "smart_summary", 10, 10);
        // Should not crash; maxSuffixLen=10/4=2, suffix gets truncated severely
        // bodyBudget may be 0 or negative => suffix or truncated content returned
        assertNotNull(result);
        assertTrue(result.length() > 0);
    }

    }
    return array;
  }

  /**
   * Returns a fixed-size list backed by the specified array, similar to {@link
   * Arrays#asList(Object[])}. The list supports {@link List#set(int, Object)}, but any attempt to
   * set a value to {@code null} will result in a {@link NullPointerException}.
   *
   * <p>The returned list maintains the values, but not the identities, of {@code Double} objects

```

1. Ici, nous utilisons l'option de ligne de commande `--workers` pour définir le nombre de workers à 4.

Voici quelques exemples où cela pourrait avoir du sens :

#### Une application simple { #a-simple-app }

Vous pourriez vouloir un gestionnaire de processus dans le conteneur si votre application est **suffisamment simple** pour s'exécuter sur un **seul serveur**, pas un cluster.