JDK对Http协议的Keep-Alive的支持，以JDK8为例
作者：互联网
JDK对Http协议的Keep-Alive的支持，以JDK8为例
Http协议对keep-alive的支持
keep-alive顾名思义就是保持连接的意思，在早期的HTTP/1.0中，每次http请求都要创建一个连接，而创建连接的过程需要消耗资源和时间，为了减少资源消耗，缩短响应时间，就需要重用连接。
在后来的HTTP/1.0中以及HTTP/1.1中，引入了重用连接的机制，就是在http请求头中加入Connection: keep-alive来告诉对方这个请求响应完成后不要关闭，下一次咱们还用这个请求继续交流。
协议规定HTTP/1.0如果想要保持长连接，需要在请求头中加上Connection: keep-alive，而HTTP/1.1默认是支持长连接的，有没有这个请求头都行。另外，一般服务端都会设置keep-alive超时时间。超过指定的时间间隔，服务端就会主动关闭连接。同时服务端还会设置一个参数叫最大请求数，比如当最大请求数是300时，只要请求次数超过300次，即使还没到超时时间，服务端也会主动关闭连接。如下图所示为服务器返回的Responser Headers的值。
Reponse Headers
Connection: Keep-Alive
Content-length: 35
content-type: application/json;charset=UTF-8
Keep-Alive: timeout=60,max=5
注意，当Connection:keep-alive存在时，下面的Keep-Alive: timeout=70, max=10才会生效。
Http协议对keep-alive的支持是基于TCP连接的成功建立，而TCP协议是对Http透明的，即TCP协议的Keep-Alive与Http的Keep-Alive是无关的。
TCP协议中的keep-Alive
TCP keepalive指的是TCP保活计时器（keepalive timer）。设想有这样的情况：客户已主动与服务器建立了TCP连接。但后来客户端的主机突然出故障。显然，服务器以后就不能再收到客户发来的数据。因此，应当有措施使服务器不要再白白等待下去。这就是使用保活计时器。服务器每收到一次客户的数据，就重新设置保活计时器，时间的设置通常是两小时。若两小时没有收到客户的数据，服务器就发送一个探测报文段，以后则每隔75秒发送一次。若一连发送10个探测报文段后仍无客户的响应，服务器就认为客户端出了故障，接着就关闭这个连接。
——摘自谢希仁《计算机网络》
JDK对Http协议的keep-alive的支持
JDK对Http协议的Keep-Alive的支持参考oracel官方说明https://docs.oracle.com/javase/8/docs/technotes/guides/net/http-keepalive.html。接下来结合jdk源码分析：
1、HttpURLConnection（java.net.HttpURLConnection）使用长连接
JDK自带的HttpURLConnection，默认启用keepAlive，支持HTTP / 1.1和HTTP / 1.0持久连接， 使用后的HttpURLConnection会放入缓存中供以后的同host:port的请求重用，底层的socket在keepAlive超时之前不会关闭。
HttpURLConnection受以下system properties控制：
http.keepAlive=（默认值：true），是否启用keepAlive，如果设置为false，则HttpURLConnection不会缓存，使用完后会关闭socket连接。（可设置）
http.maxConnections=（默认值：5），每个目标host缓存socket连接的最大数。（当http.keepAlive=false时为1，否则为5，下面结合源码分析）
2、sun.net.www.http包下的HttpURLConnection和HttpClient长连接缓存
sun.net.www.http.HttpURLConnection是java.net.HttpURLConnection的实现类，JDK自带的HttpURLConnection底层使用JDK自带的HttpClient发送http请求，java8的HttpClient（sun.net.www.http.HttpClient）存在诸多限制，在Jdk11中，java.net.HttpClient吸收第三方HttpClient的优点，性能肩比第三方HttpClient(okHttptClitn，apache Httpclient)。
下面为sun.net.www.http.HttpURLConnection.HttpURLConnection类，有如下两个方法返回HttpClient的实例和直接关闭socket的disconnect()方法。
public class HttpURLConnection extends java.net.HttpURLConnection {
// subclass HttpsClient will overwrite & return an instance of HttpsClient
protected HttpClient getNewHttpClient(URL url, Proxy p, int connectTimeout)
throws IOException {
return HttpClient.New(url, p, connectTimeout, this);
}
// subclass HttpsClient will overwrite & return an instance of HttpsClient
protected HttpClient getNewHttpClient(URL url, Proxy p, int connectTimeout, boolean useCache)
throws IOException {
return HttpClient.New(url, p, connectTimeout, useCache, this);
}
/**
* Disconnect from the server (public API)
*/
public void disconnect() {
}
}
下面为HttpClient类，parseHTTPHeader会解析header参数，判断HttpURLConnection是否是长连接，如果是长连接会读取keepAliveTimeout参数作为KeepAliveCache类里的长连接的缓存有效时间（默认为0）。并设置keepAliveConnections的值，如过为长连接值为5，否则为1。
完成获取请求返回结果后或调用getInputStream().close()，JDK会清理连接并作为以后使用的连接缓存。具体逻辑为执行finished()方法，如果是短连接，直接关闭套接字（调用closeServer()方法），如果是长连接，则将这个长连接加到KeepAliveCache的缓存线程中（putInKeepAliveCache()方法）。
其中，protected static KeepAliveCache kac = new KeepAliveCache();代码表面运行时只有全局只有一个缓存的线程类。
public class HttpClient extends NetworkClient {
// whether this httpclient comes from the cache
protected boolean cachedHttpClient = false;
protected boolean inCache;
/* where we cache currently open, persistent connections */
protected static KeepAliveCache kac = new KeepAliveCache();
private static boolean keepAliveProp = true;
private boolean parseHTTPHeader(MessageHeader responses, ProgressSource pi, HttpURLConnection httpuc){
keepAliveConnections = -1;
keepAliveTimeout = 0;
}
public void finished() {
if (reuse) /* will be reused */
return;
keepAliveConnections--;
poster = null;
if (keepAliveConnections > 0 && isKeepingAlive() &&
!(serverOutput.checkError())) {
/* This connection is keepingAlive && still valid.
* Return it to the cache.
*/
putInKeepAliveCache();
} else {
closeServer();
}
}
protected synchronized void putInKeepAliveCache() {
if (inCache) {
assert false : "Duplicate put to keep alive cache";
return;
}
inCache = true;
kac.put(url, null, this);
}
}
KeepAliveCache继承了HashMap，实现了Runnable接口。
它本身可以存储不同的KeepAliveKey-ClientVector，KeepAliveKey是关于协议（一般为http），ip，port类，对应了一个socket连接。ClientVector实现了双端队列，存储了HttpClient实例和idleStartTime（该HttpClient开始空闲的时间），最多可以存5个，对应HttpClient类的keepAliveConnections。ClientVector还有一个属性nap，即缓存过期时间，在put()方法实例化时设置，new ClientVector(keepAliveTimeout > 0 ? keepAliveTimeout * 1000 : LIFETIME)
KeepAliveCache也是一个线程类，run方法的逻辑是do-while循环检测HashMap中缓存的长连接是否timeout，如果超时就清理，当HashMap为空时，线程完成自己的逻辑，执行完毕。
KeepAliveCache提供put()方法，运行时KeepAliveCache线程类全局只有一个，没有缓存的线程类时，在put()方法中创建该缓存类keepAliveTimer，并设置长连接的缓存时间。
public class KeepAliveCache
extends HashMap<KeepAliveKey, ClientVector>
implements Runnable {
/* Sleeps for an alloted timeout, then checks for timed out connections.
* Errs on the side of caution (leave connections idle for a relatively
* short time).
*/
@Override
public void run() {
do {
try {
Thread.sleep(LIFETIME);
} catch (InterruptedException e) {}
// Remove all outdated HttpClients.
synchronized (this) {
long currentTime = System.currentTimeMillis();
List<KeepAliveKey> keysToRemove = new ArrayList<>();
for (KeepAliveKey key : keySet()) {
ClientVector v = get(key);
synchronized (v) {
KeepAliveEntry e = v.peek();
while (e != null) {
if ((currentTime - e.idleStartTime) > v.nap) {
v.poll();
e.hc.closeServer();
} else {
break;
}
e = v.peek();
}
if (v.isEmpty()) {
keysToRemove.add(key);
}
}
}
for (KeepAliveKey key : keysToRemove) {
removeVector(key);
}
}
} while (!isEmpty());
}
/**
* Register this URL and HttpClient (that supports keep-alive) with the cache
* @param url The URL contains info about the host and port
* @param http The HttpClient to be cached
*/
public synchronized void put(final URL url, Object obj, HttpClient http) {
boolean startThread = (keepAliveTimer == null);
if (!startThread) {
if (!keepAliveTimer.isAlive()) {
startThread = true;
}
}
if (startThread) {
clear();
/* Unfortunately, we can't always believe the keep-alive timeout we got
* back from the server. If I'm connected through a Netscape proxy
* to a server that sent me a keep-alive
* time of 15 sec, the proxy unilaterally terminates my connection
* The robustness to get around this is in HttpClient.parseHTTP()
*/
final KeepAliveCache cache = this;
AccessController.doPrivileged(new PrivilegedAction<>() {
public Void run() {
keepAliveTimer = InnocuousThread.newSystemThread("Keep-Alive-Timer", cache);
keepAliveTimer.setDaemon(true);
keepAliveTimer.setPriority(Thread.MAX_PRIORITY - 2);
keepAliveTimer.start();
return null;
}
});
}
KeepAliveKey key = new KeepAliveKey(url, obj);
ClientVector v = super.get(key);
if (v == null) {
int keepAliveTimeout = http.getKeepAliveTimeout();
v = new ClientVector(keepAliveTimeout > 0 ?
keepAliveTimeout * 1000 : LIFETIME);
v.put(http);
super.put(key, v);
} else {
v.put(http);
}
}
class ClientVector extends ArrayDeque<KeepAliveEntry> {
// sleep time in milliseconds, before cache clear
int nap;
ClientVector(int nap) {
this.nap = nap;
}
}
class KeepAliveKey {
private String protocol = null;
private String host = null;
private int port = 0;
private Object obj = null; // additional key, such as socketfactory
/**
* Constructor
* @param url the URL containing the protocol, host and port information
*/
public KeepAliveKey(URL url, Object obj) {
this.protocol = url.getProtocol();
this.host = url.getHost();
this.port = url.getPort();
this.obj = obj;
}
}
class KeepAliveEntry {
HttpClient hc;
long idleStartTime;
KeepAliveEntry(HttpClient hc, long idleStartTime) {
this.hc = hc;
this.idleStartTime = idleStartTime;
}
}
}
3、HttpURLConnection使用短连接
3.1）使用短连接，不缓存长连接
设置System.setProperty(“http.keepAlive”, ”false”);将整个 APP 的 http 长连接支持关掉。不会启动新的线程去缓存HttpClient连接，在HttpClient类的finished方法里不执行缓存连接的操作，直接关闭socket连接。
3.2）客户端不使用keep-alive功能
HttpURLConnection的实例获取到服务方的数据后直接关闭HttClient(关闭socket)，不缓存如下所示：
//第一种，Header指定短连接
httpConn.setRequestProperty("Connection", "close");
//第二种，请求完后直接关闭socket
httpURLConnection.disconnect();
3.3）服务端长连接关闭
返回的Response Header中包含Connection:close即可。
参考另外几位大佬们的文章：
http://www.itersblog.com/archives/3.html
https://blog.csdn.net/u012216753/article/details/78084327
https://blog.csdn.net/tianshouzhi/article/details/103922842?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-5&spm=1001.2101.3001.4242
标签：缓存,http,JDK,为例,keep,Http,连接,HttpURLConnection,HttpClient 来源： https://blog.csdn.net/qq_38997816/article/details/117533323