sequence
This article focuses on the ConnectionPool of the JDK HttpClient
HttpConnection
HttpConnection.getConnection
java.net.http/jdk/internal/net/http/HttpConnection.java
/**
* Factory for retrieving HttpConnections. A connection can be retrieved
* from the connection pool, or a new one created if none available.
*
* The given {@code addr} is the ultimate destination. Any proxies,
* etc, are determined from the request. Returns a concrete instance which
* is one of the following:
* {@link PlainHttpConnection}
* {@link PlainTunnelingConnection}
*
* The returned connection, if not from the connection pool, must have its,
* connect() or connectAsync() method invoked, which ( when it completes
* successfully ) renders the connection usable for requests.
*/
public static HttpConnection getConnection(InetSocketAddress addr,
HttpClientImpl client,
HttpRequestImpl request,
Version version) {
// The default proxy selector may select a proxy whose address is
// unresolved. We must resolve the address before connecting to it.
InetSocketAddress proxy = Utils.resolveAddress(request.proxy());
HttpConnection c = null;
boolean secure = request.secure();
ConnectionPool pool = client.connectionPool();
if(! secure) { c = pool.getConnection(false, addr, proxy);
if(c ! = null && c.isOpen() /* may have been eof/closed whenin the pool */) {
final HttpConnection conn = c;
if (DEBUG_LOGGER.on())
DEBUG_LOGGER.log(conn.getConnectionFlow()
+ "The plainConnection retrieved from HTTP/1.1 Pool");
return c;
} else {
returngetPlainConnection(addr, proxy, request, client); }}else { // secure
if (version != HTTP_2) { // only HTTP/1.1 connections are in the pool
c = pool.getConnection(true, addr, proxy);
}
if(c ! = null && c.isOpen()) { final HttpConnection conn = c;if (DEBUG_LOGGER.on())
DEBUG_LOGGER.log(conn.getConnectionFlow()
+ "The spectrum of SSL Connection retrieved from HTTP/1.1 Pool");
return c;
} else {
String[] alpn = null;
if (version == HTTP_2 && hasRequiredHTTP2TLSVersion(client)) {
alpn = new String[] { "h2"."HTTP / 1.1" };
}
returngetSSLConnection(addr, proxy, alpn, request, client); }}}Copy the code- GetConnection (true, addr, proxy)
HttpConnection.closeOrReturnToCache
java.net.http/jdk/internal/net/http/HttpConnection.java
void closeOrReturnToCache(HttpHeaders hdrs) {
if (hdrs == null) {
// the connection was closed by server, eof
close();
return;
}
if(! isOpen()) {return;
}
HttpClientImpl client = client();
if (client == null) {
close();
return;
}
ConnectionPool pool = client.connectionPool();
boolean keepAlive = hdrs.firstValue("Connection") .map((s) -> ! s.equalsIgnoreCase("close"))
.orElse(true);
if (keepAlive) {
Log.logTrace("Returning connection to the pool: {0}", this);
pool.returnToPool(this);
} else{ close(); }}Copy the code- Call pool.returntopool (this) to return the connection
ConnectionPool
java.net.http/jdk/internal/net/http/ConnectionPool.java
Http 1.1 Connection pool. */ final class ConnectionPool {static final long KEEP_ALIVE = Utils.getIntegerNetProperty("jdk.httpclient.keepalive.timeout", 1200); // seconds
static final long MAX_POOL_SIZE = Utils.getIntegerNetProperty(
"jdk.httpclient.connectionPoolSize", 0); // unbounded
final Logger debug = Utils.getDebugLogger(this::dbgString, Utils.DEBUG);
// Pools of idle connections
private final HashMap<CacheKey,LinkedList<HttpConnection>> plainPool;
private final HashMap<CacheKey,LinkedList<HttpConnection>> sslPool;
private final ExpiryList expiryList;
private final String dbgTag; // used fordebug boolean stopped; / /... /** * Entriesin connection pool are keyed by destination address and/or
* proxy address:
* case 1: plain TCP not via proxy (destination only)
* case 2: plain TCP via proxy (proxy only)
* case 3: SSL not via proxy (destination only)
* case 4: SSL over tunnel (destination and proxy)
*/
static class CacheKey {
final InetSocketAddress proxy;
final InetSocketAddress destination;
CacheKey(InetSocketAddress destination, InetSocketAddress proxy) {
this.proxy = proxy;
this.destination = destination;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if(getClass() ! = obj.getClass()) {return false;
}
final CacheKey other = (CacheKey) obj;
if(! Objects.equals(this.proxy, other.proxy)) {return false;
}
if(! Objects.equals(this.destination, other.destination)) {return false;
}
return true;
}
@Override
public int hashCode() {
return Objects.hash(proxy, destination);
}
}
synchronized HttpConnection getConnection(boolean secure,
InetSocketAddress addr,
InetSocketAddress proxy) {
if (stopped) return null;
CacheKey key = new CacheKey(addr, proxy);
HttpConnection c = secure ? findConnection(key, sslPool)
: findConnection(key, plainPool);
//System.out.println ("getConnection returning: " + c);
return c;
}
private HttpConnection
findConnection(CacheKey key,
HashMap<CacheKey,LinkedList<HttpConnection>> pool) {
LinkedList<HttpConnection> l = pool.get(key);
if (l == null || l.isEmpty()) {
return null;
} else {
HttpConnection c = l.removeFirst();
expiryList.remove(c);
return c;
}
}
/**
* Returns the connection to the pool.
*/
void returnToPool(HttpConnection conn) {
returnToPool(conn, Instant.now(), KEEP_ALIVE);
}
// Called also by whitebox tests
void returnToPool(HttpConnection conn, Instant now, long keepAlive) {
// Don't call registerCleanupTrigger while holding a lock, // but register it before the connection is added to the pool, // since we don't want to trigger the cleanup if the connection
// is not in the pool.
CleanupTrigger cleanup = registerCleanupTrigger(conn);
// it's possible that cleanup may have been called.
HttpConnection toClose = null;
synchronized(this) {
if (cleanup.isDone()) {
return;
} else if (stopped) {
conn.close();
return;
}
if (MAX_POOL_SIZE > 0 && expiryList.size() >= MAX_POOL_SIZE) {
toClose = expiryList.removeOldest();
if (toClose != null) removeFromPool(toClose);
}
if (conn instanceof PlainHttpConnection) {
putConnection(conn, plainPool);
} else {
assert conn.isSecure();
putConnection(conn, sslPool);
}
expiryList.add(conn, now, keepAlive);
}
if (toClose != null) {
if (debug.on()) {
debug.log("Maximum pool size reached: removing oldest connection %s",
toClose.dbgString());
}
close(toClose);
}
//System.out.println("Return to pool: " + conn);
}
private void removeFromPool(HttpConnection c) {
assert Thread.holdsLock(this);
if (c instanceof PlainHttpConnection) {
removeFromPool(c, plainPool);
} else {
assert c.isSecure();
removeFromPool(c, sslPool);
}
}
private boolean
removeFromPool(HttpConnection c,
HashMap<CacheKey,LinkedList<HttpConnection>> pool) {
//System.out.println("cacheCleaner removing: " + c);
assert Thread.holdsLock(this);
CacheKey k = c.cacheKey();
List<HttpConnection> l = pool.get(k);
if (l == null || l.isEmpty()) {
pool.remove(k);
return false;
}
return l.remove(c);
}
private void
putConnection(HttpConnection c,
HashMap<CacheKey,LinkedList<HttpConnection>> pool) {
CacheKey key = c.cacheKey();
LinkedList<HttpConnection> l = pool.get(key);
if (l == null) {
l = new LinkedList<>();
pool.put(key, l);
}
l.add(c);
}
void stop() {
List<HttpConnection> closelist = Collections.emptyList();
try {
synchronized (this) {
stopped = true;
closelist = expiryList.stream()
.map(e -> e.connection)
.collect(Collectors.toList());
expiryList.clear();
plainPool.clear();
sslPool.clear();
}
} finally {
closelist.forEach(this::close);
}
}
}
Copy the code- Borrow a connection to call the getConnection method, and finally call the findConnection method to remove the first one from LinkedList> and remove the connection from expiryList
- If you have an expiryList that is larger than MAX_POOL_SIZE, then you would like to remove the old one from your expiryList and HashMap
and close it. Then call putConnection to add that connection to HashMap
, and finally add that connection to expiryList
- ConnectionPool maintains HashMap
and ExpiryList as two important attributes. If MAX_POOL_SIZE is greater than 0, the expiryList size will be determined. If MAX_POOL_SIZE is larger than 0, the oldest connection will be removed and removed from both locations
- MAX_POOL_SIZE reads the JDK. Httpclient. ConnectionPoolSize, read less than the default is 0, said is infinite
- ConnectionPool has a stop method that is called at HttpClient’s stop (
Triggered when the SelectorManager thread exits), the stop method clears the pool and closes the connection
ExpiryList
java.net.http/jdk/internal/net/http/ConnectionPool.java
/**
* Manages a LinkedList of sorted ExpiryEntry. The entry with the closer
* deadline is at the tail of the list, and the entry with the farther
* deadline is at the head. In the most common situation, new elements
* will need to be added at the head (or close to it), and expired elements
* will need to be purged from the tail.
*/
private static final class ExpiryList {
private final LinkedList<ExpiryEntry> list = new LinkedList<>();
private volatile boolean mayContainEntries;
int size() { return list.size(); }
// A loosely accurate boolean whose value is computed
// at the end of each operation performed on ExpiryList;
// Does not require synchronizing on the ConnectionPool.
boolean purgeMaybeRequired() {
return mayContainEntries;
}
// Returns the next expiry deadline
// should only be called while holding a synchronization
// lock on the ConnectionPool
Optional<Instant> nextExpiryDeadline() {
if (list.isEmpty()) return Optional.empty();
else return Optional.of(list.getLast().expiry);
}
// should only be called while holding a synchronization
// lock on the ConnectionPool
HttpConnection removeOldest() {
ExpiryEntry entry = list.pollLast();
return entry == null ? null : entry.connection;
}
// should only be called while holding a synchronization
// lock on the ConnectionPool
void add(HttpConnection conn) {
add(conn, Instant.now(), KEEP_ALIVE);
}
// Used by whitebox test.
void add(HttpConnection conn, Instant now, long keepAlive) {
Instant then = now.truncatedTo(ChronoUnit.SECONDS)
.plus(keepAlive, ChronoUnit.SECONDS);
// Elements with the farther deadline are at the head of
// the list. It's more likely that the new element will // have the farthest deadline, and will need to be inserted // at the head of the list, so we're using an ascending
// list iterator to find the right insertion point.
ListIterator<ExpiryEntry> li = list.listIterator();
while (li.hasNext()) {
ExpiryEntry entry = li.next();
if (then.isAfter(entry.expiry)) {
li.previous();
// insert here
li.add(new ExpiryEntry(conn, then));
mayContainEntries = true;
return;
}
}
// last (or first) element of list (the last element is
// the first when the list is empty)
list.add(new ExpiryEntry(conn, then));
mayContainEntries = true;
}
// should only be called while holding a synchronization
// lock on the ConnectionPool
void remove(HttpConnection c) {
if (c == null || list.isEmpty()) return;
ListIterator<ExpiryEntry> li = list.listIterator();
while (li.hasNext()) {
ExpiryEntry e = li.next();
if(e.connection.equals(c)) { li.remove(); mayContainEntries = ! list.isEmpty();return;
}
}
}
// should only be called while holding a synchronization
// lock on the ConnectionPool.
// Purge all elements whose deadline is before now (now included).
List<HttpConnection> purgeUntil(Instant now) {
if (list.isEmpty()) return Collections.emptyList();
List<HttpConnection> closelist = new ArrayList<>();
// elements with the closest deadlines are at the tail
// of the queue, so we're going to use a descending iterator // to remove them, and stop when we find the first element // that has not expired yet. Iterator
li = list.descendingIterator(); while (li.hasNext()) { ExpiryEntry entry = li.next(); // use ! isAfter instead of isBefore in order to // remove the entry if its expiry == now if (! entry.expiry.isAfter(now)) { li.remove(); HttpConnection c = entry.connection; closelist.add(c); } else break; // the list is sorted } mayContainEntries = ! list.isEmpty(); return closelist; } // should only be called while holding a synchronization // lock on the ConnectionPool java.util.stream.Stream
stream() { return list.stream(); } // should only be called while holding a synchronization // lock on the ConnectionPool void clear() { list.clear(); mayContainEntries = false; } } static final class ExpiryEntry { final HttpConnection connection; final Instant expiry; // absolute time in seconds of expiry time ExpiryEntry(HttpConnection connection, Instant expiry) { this.connection = connection; this.expiry = expiry; }}
Copy the code- Context List uses LinkedList inside, and context Entry wraps a Connection
- ExpiryEntry has HttpConnection in it as well as expiry time
- Of ExpiryList add operation is based on the current number of seconds + KEEP_ALIVE parameters to calculate the expiry time, KEEP_ALIVE read is JDK httpclient.. Keepalive timeout, read less than the default is 1200 seconds; It is then inserted into the LinkedList based on the expiration time, with the longest expiration time at the head of the list and the near expiration time at the end of the list
- PollLast removes the oldest of your ExpiryList. PollLast removes a specific connection. ListIterator traverses the LinkedList for matching and then removes it
- The mayContainEntries variable is maintained and updated when LinkedList is operated on to return whether the ExpiryList has a connection, so that ConnectionPool is not called synchronously when necessary
ConnectionPool.purgeExpiredConnectionsAndReturnNextDeadline
java.net.http/jdk/internal/net/http/ConnectionPool.java
/**
* Purge expired connection and return the number of milliseconds
* in which the next connection is scheduled to expire.
* If no connections are scheduled to be purged return 0.
* @return the delay in milliseconds in which the next connection will
* expire.
*/
long purgeExpiredConnectionsAndReturnNextDeadline() {
if(! expiryList.purgeMaybeRequired())return 0;
return purgeExpiredConnectionsAndReturnNextDeadline(Instant.now());
}
// Used for whitebox testing
long purgeExpiredConnectionsAndReturnNextDeadline(Instant now) {
long nextPurge = 0;
// We may be in the process of adding new elements
// to the expiry list - but those elements will not
// have outlast their keep alive timer yet since we're // just adding them. if (! expiryList.purgeMaybeRequired()) return nextPurge; List
closelist; synchronized (this) { closelist = expiryList.purgeUntil(now); for (HttpConnection c : closelist) { if (c instanceof PlainHttpConnection) { boolean wasPresent = removeFromPool(c, plainPool); assert wasPresent; } else { boolean wasPresent = removeFromPool(c, sslPool); assert wasPresent; } } nextPurge = now.until( expiryList.nextExpiryDeadline().orElse(now), ChronoUnit.MILLIS); } closelist.forEach(this::close); return nextPurge; }
Copy the code- Because of the connection with the failure time of ExpiryList, thus clear the failure of the connection step, this step is done through purgeExpiredConnectionsAndReturnNextDeadline
- PurgeExpiredConnectionsAndReturnNextDeadline method is called SelectorManager, used to calculate the selector, select the timeout time
- . This method first calls expiryList purgeMaybeRequired access mayContainEntries (), see expiryList presence of connection, not connected directly returns 0; Then call EXPIRyList.purgeuntil (now) to remove and retrieve currently expired connections, remove them one by one from HashMap
and calculate the nextPurge, and close the removed connections one by one
CleanupTrigger
java.net.http/jdk/internal/net/http/ConnectionPool.java
private CleanupTrigger registerCleanupTrigger(HttpConnection conn) {
// Connect the connection flow to a pub/sub pair that will take the
// connection out of the pool and close it if anything happens
// while the connection is sitting in the pool.
CleanupTrigger cleanup = new CleanupTrigger(conn);
FlowTube flow = conn.getConnectionFlow();
if (debug.on()) debug.log("registering %s", cleanup);
flow.connectFlows(cleanup, cleanup);
return cleanup;
}
void cleanup(HttpConnection c, Throwable error) {
if (debug.on())
debug.log("%s : ConnectionPool.cleanup(%s)",
String.valueOf(c.getConnectionFlow()), error);
synchronized(this) {
removeFromPool(c);
expiryList.remove(c);
}
c.close();
}
/**
* An object that subscribes to the flow while the connection is in
* the pool. Anything that comes in will cause the connection to be closed
* and removed from the pool.
*/
private final class CleanupTrigger implements
FlowTube.TubeSubscriber, FlowTube.TubePublisher,
Flow.Subscription {
private final HttpConnection connection;
private volatile boolean done;
public CleanupTrigger(HttpConnection connection) {
this.connection = connection;
}
public boolean isDone() { return done; } private void triggerCleanup(Throwable error) {done = true;
cleanup(connection, error);
}
@Override public void request(long n) {}
@Override public void cancel() {}
@Override
public void onSubscribe(Flow.Subscription subscription) {
subscription.request(1);
}
@Override
public void onError(Throwable error) { triggerCleanup(error); }
@Override
public void onComplete() { triggerCleanup(null); }
@Override
public void onNext(List<ByteBuffer> item) {
triggerCleanup(new IOException("Data received while in pool"));
}
@Override
public void subscribe(Flow.Subscriber<? super List<ByteBuffer>> subscriber) {
subscriber.onSubscribe(this);
}
@Override
public String toString() {
return "CleanupTrigger(" + connection.getConnectionFlow() + ")"; }}Copy the code- When returnToPool is called, registerCleanupTrigger is called, a CleanupTrigger is created, and conn.getConnectionFlow() is called to get the flow, ConnectFlows (cleanup, cleanup)
- The CleanupTrigger is both flowTube. TubeSubscriber and flowtubepublisher, calling the cleanup method in the onComplete and onError methods, Remove a connection from HashMap
and expiryList
- The CleanupTrigger may function like an active connection health check, notifying the connection pool when the underlying connection is abnormally closed, triggering a cleanup of dirty connections
summary
- JDK HttpClient ConnectionPool is relatively simple compared to Apache Common Pools.
It actually does ExpiryList) :
MAX_POOL_SIZE (JDK. Httpclient. ConnectionPoolSize). Default is 0, said infinite KEEP_ALIVE (JDK. Httpclient. Keepalive. A timeout), default is 1200 seconds
- ConnectionPool maintains two properties: HashMap
and expiryList. The former uses a target IP address and a proxy address as cachekeys, each of which maintains a ConnectionPool. The latter, regardless of cacheKey, wraps each connection in the pool and records the expiration time according to KEEP_ALIVE.
- SelectorManager call purgeExpiredConnectionsAndReturnNextDeadline select the timeout time calculation, this method will clean up (
Remove and close) Expired connection - In addition to the SelectorManager cleaning up expired connections, the Connection also indirectly triggers a CleanupTrigger via FlowTube to clean up closed or abnormal connections
doc
- java.net.http javadoc