一个调用第三方接口的任务,白天跑得好好的,凌晨偶尔会卡住。日志停在 client.send(request, ...) 这一行,之后什么都没有,线程一直活着,但既不返回也不报错。重启之后恢复正常,下一次又不知道什么时候复发。

这不是死锁,是「没有设置超时」。Java 的 HttpClient 如果不显式指定请求超时,就会一直等下去;底层 TCP 连接只要没断,它就有理由相信对方还会回话。对方服务器卡住、网络中间设备静默丢包、代理不响应,都会让这个等待变成无限期。

这篇讲两套 API:面向 HTTP 的 java.net.http.HttpClient,和面向 TCP 的 Socket。重点不是发请求的语法,而是「等多久」「什么时候算读完」「资源什么时候释放」这三件事。网络编程里绝大多数线上问题,都出在这三件事上。

HttpClient:建一次,反复用

HttpClient 是 JDK 11 引入的 HTTP 客户端,替代了老旧的 HttpURLConnection。它是不可变对象,创建之后可以安全地被多个线程共享,内部维护连接池。正确的用法是全局建一个,而不是每次请求都 new 一个。每次新建不仅浪费连接,还会让连接池和线程资源反复创建销毁。

一次 HttpClient 请求的主要步骤
构造 HttpClient
构造 HttpRequest
建立或复用连接
发送请求
读取响应体
释放连接

HttpRequest 也是不可变的,用 Builder 构造:指定 URI、方法、请求头、超时和请求体。GET 不需要 body,POST 用 BodyPublishers.ofString 之类发布请求体。发送用 send 会阻塞当前线程,用 sendAsync 返回 CompletableFuture,适合不想占线程的场景。

响应由 HttpResponse 表示,泛型参数是响应体的类型。具体怎么读由 BodyHandler 决定:ofString 读成字符串,ofByteArray 读成字节数组,ofInputStream 返回输入流,ofFile 直接落盘。选哪种决定了内存占用和是否需要手动关闭。

sendAsync 返回的 CompletableFuture 可以继续链式组合:拿到响应后转换、合并、处理异常。它的回调默认在 HttpClient 自己的线程池里执行,不要在回调里做耗时阻塞操作,否则会拖慢其他回调。需要控制执行线程时,用带 Executor 参数的 thenApplyAsync 指定自己的线程池。

HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(2))
        .build();
HttpRequest req = HttpRequest.newBuilder(URI.create("http://127.0.0.1:" + port + "/hello"))
        .timeout(Duration.ofSeconds(2))
        .GET()
        .build();
HttpResponse<String> resp = client.send(req,
        HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
System.out.println(resp.statusCode());
System.out.println(resp.body());
System.out.println(resp.version());
javac -encoding UTF-8 JavaNetDemo.java
java -Dstdout.encoding=UTF-8 -cp . JavaNetDemo

状态码 : 200
正文 : 你好,HttpClient
HTTP 版本 : HTTP_1_1

这段输出是本机起了一个 com.sun.net.httpserver.HttpServer 之后真实跑出来的。注意 ofString 显式传了 UTF_8:不传时它会参考响应头的 Content-Type,拿不到就按 UTF-8 处理,但显式指定更稳,能避免服务端头写错导致的乱码。HTTP 版本显示 HTTP_1_1,因为这里用的是明文 HTTP;用 HTTPS 时默认会尝试 HTTP/2。

两种超时:连接超时和请求超时

HttpClient 有两个容易混淆的超时设置。connectTimeout 管的是「建立 TCP 连接」这一步,超过这个时间还没连上就放弃;HttpRequest.timeout 管的是「整个请求到响应」的时间,从发出请求算起。只设其中一个,另一个仍然是无限等待。

下面这段代码对端处理需要 2 秒,请求超时设成 500 毫秒,实际跑出来会抛异常:

HttpRequest slow = HttpRequest.newBuilder(URI.create("http://127.0.0.1:" + port + "/slow"))
        .timeout(Duration.ofMillis(500))
        .GET()
        .build();
try {
    client.send(slow, HttpResponse.BodyHandlers.ofString());
} catch (HttpTimeoutException e) {
    System.out.println(e.getClass().getSimpleName());
}
HttpTimeoutException

异常类型是 HttpTimeoutException,它继承自 IOException,所以只捕获 IOException 也能兜住,但分不清是超时还是别的网络错误。线上建议单独捕获,并在日志里带上目标地址和设置的超时值,否则事后只能看到「请求失败」四个字。

不要给所有请求设一个「够大」的超时,比如 60 秒。超时的意义是「超过这个时间我就不等了」,设得太大等于没设。连接超时通常几秒,请求超时要按接口的正常耗时来定,并留出合理余量。

写操作也可能卡住。发送一个很大的请求体,对端读得慢,TCP 的发送缓冲区满了,写入就会阻塞。请求超时能否覆盖这一段,取决于具体实现和阶段,稳妥的做法是控制请求体大小,并给整个调用链路设置总预算。不要只给「等响应」设超时,却忽略了「写请求」也可能无限等待。

还有一种情况是超时了但异常信息里看不出目标地址。捕获之后自己补一条日志,带上 URI、超时值、当前耗时,别只打印异常类名。网络问题往往需要跨服务对数,信息越全,排查越快。

还有一个细节:send 抛出的 InterruptedException 不能忽略。捕获之后要恢复中断标记(Thread.currentThread().interrupt()),否则上层依赖中断的取消逻辑会失效。这在下一篇讲线程和异步时还会遇到。

响应体:不读、不关,连接就回不到池子里

HTTP 连接要复用,前一个响应必须被完整读完。如果用的是 ofString、ofByteArray 这类处理器,它们会替你读完,正常情况下不需要额外处理。如果用的是 ofInputStream,就必须自己把流读到结尾或者关闭,否则这条连接可能被丢弃。

丢弃连接不会立刻报错,它只是让连接池少一条可用连接。请求量一大,池子里的连接不断被占死,新建连接越来越多,端口和文件句柄跟着上涨。表现出来的现象是「跑一段时间之后开始变慢、偶尔连接超时」,重启又好了。这类问题只看业务日志永远查不出来。

ofInputStream 的另一个坑是它必须在响应对象还有效时消费完。很多人把流交给别的线程慢慢读,主线程已经返回,结果读到一半连接被回收。要用流式处理,就在同一个调用链里处理完,或者用 ofFile 落到临时文件再处理。

还有响应体大小。默认情况下,ofString 会把整个响应读进内存,对端返回一个几百兆的文件就会撑爆堆。下载大文件应该用 ofFile 或 ofInputStream,并限制最大读取量。不要相信对端「不会返回这么大」的承诺,错误配置和恶意请求都会发生。

响应怎么算「读完」,HTTP 有两套机制。带 Content-Length 的响应,长度到了就结束;用分块传输(chunked)的响应,以一个长度为 0 的块作为结束标记。如果两者都没有,就只能等连接关闭,而连接关闭又会让这条连接无法复用。这些细节平时不用手写,但排查「为什么连接没复用」时需要知道。

应用层HttpClient、HttpRequest、HttpResponse。负责方法、头、状态码、响应体的语义。
连接层TLS、代理、连接池、HTTP 版本协商。负责复用和加密,出问题往往表现为连接超时或握手失败。
传输层TCP Socket。负责可靠传输,没有消息边界,读操作可能只拿到一部分数据。

这三层的故障表现不同:状态码不对是应用层,连接超时通常是连接层或传输层,读到半截数据是传输层。排查时先分清在哪一层,再去翻对应的配置。传输层为什么会有「半包」,和操作系统的 I/O 模型与缓冲区设计有关,细节可以看 操作系统:I/O 模型。

Socket:read 返回 -1 不是错误,是对方关了

Socket 是最基础的 TCP 客户端,ServerSocket 是对应的服务端。它不帮你解析 HTTP,也不帮你分消息,你拿到的就是一个字节流。流的特点是「没有边界」:对方发了两次数据,你可能一次读完,也可能分三次读到。协议必须自己定,比如按换行分隔、按长度前缀,或者读到流结束。

try (ServerSocket ss = new ServerSocket(0)) {
    int p = ss.getLocalPort();
    // 另一个线程 accept 后写入一行并关闭
    try (Socket s = new Socket("127.0.0.1", p)) {
        System.out.println(s.getSoTimeout());
        s.setSoTimeout(3000);
        BufferedReader r = new BufferedReader(
                new InputStreamReader(s.getInputStream(), StandardCharsets.UTF_8));
        System.out.println(r.readLine());
        System.out.println(r.readLine());
    }
}
默认读超时 : 0
Socket 收到 : 一行文本
连接关闭后再读 : null

第一行输出 0,意思是读超时为 0,也就是「永远等下去」。这是 Socket 的默认行为,不是 bug。对端不发数据也不关闭连接,read 就会一直阻塞。正确做法是连上之后调用 setSoTimeout,单位是毫秒;超时后抛出 SocketTimeoutException,连接本身还可以继续用。

第二行读到了对方写的一行。第三行输出 null,因为对方已经关闭连接,readLine 读到流末尾返回 null。底层的 InputStream.read 在这种情况下返回 -1,不是抛出异常。-1 是一个正常信号,表示「没有更多数据了」。把 -1 当成错误码、或者把 null 当成空字符串继续处理,是读 Socket 时最常见的错误。

连接超时同样要单独设置。直接 new Socket(host, port) 会一直尝试连接,直到系统层面的超时(可能几十秒到几分钟)。更可控的写法是先 new Socket(),再 connect(new InetSocketAddress(host, port), 1000)。端口没人监听时抛出 ConnectException,主机名解析失败时抛出 UnknownHostException,两者要分开处理。

服务端这边,accept 是阻塞的,ServerSocket 也要设 setSoTimeout 才能让 accept 有机会返回。每个连接通常交给一个线程或线程池处理,连接数一多,线程数就是瓶颈。这也是虚拟线程要解决的问题,下一篇会讲。

自己定协议时,最容易被忽略的是「半包」和「粘包」。发送方写了一个 100 字节的消息,接收方可能先读到 40 字节,过一会儿再读到剩下的 60 字节;也可能两条消息合在一次读里返回。按行分隔的协议要求每条消息都以换行结尾,按长度前缀的协议要求先读长度再读正文。没有协议的裸读,只能靠连接关闭来界定结束,那意味着一个连接只能用一次。

DNS、代理与重定向:默认行为未必是你要的

HttpClient 的默认配置有几处值得确认。代理方面,它使用 JVM 默认的 ProxySelector,通常读系统属性 http.proxyHost 这类配置;环境变量 HTTP_PROXY 不一定会被自动采用。在容器里跑的程序,如果依赖环境变量里的代理,最好显式构造 ProxySelector 并传给 Builder。

重定向方面,默认策略是 Redirect.NEVER,也就是不跟随。对端返回 301 或 302,你就拿到 301 或 302,不会自动跳到新地址。需要跟随就显式设置 followRedirects(Redirect.NORMAL),但要注意跨域重定向会丢掉认证头,这是安全设计,不是 bug。

DNS 解析结果会被 JVM 缓存。长时间运行的程序,如果服务端换了 IP,客户端可能还在用旧地址,直到缓存过期。这不是 HttpClient 独有的问题,所有基于 InetAddress 的实现都一样。排查「只有部分机器连不上」时,先对比各机器的 DNS 和缓存时间。

还有一个常见误会:把 UnknownHostException 当成「网络不通」。它只表示域名解析失败,可能的原因是域名拼错、DNS 服务器不可达、容器里没有配置 DNS。网络通不通是下一层的事,先确认解析结果,再查连通性。

用 HTTPS 时,连接建立后还要做 TLS 握手。握手失败的表现可能是 SSLHandshakeException,原因包括证书过期、域名不匹配、客户端缺少根证书、协议版本或加密套件不兼容。这类问题不能靠「多试几次」解决,先把证书链和主机名验证弄清楚。自签名证书要导入信任库,不能图省事关掉校验。

出问题时先看哪里

现象真实原因第一步查什么
请求一直不返回,线程停在 send没有设置请求超时,底层连接也没断看 HttpRequest.timeout 是否设置;线程栈里是不是停在 socketRead
抛出 HttpTimeoutException请求超过了设定的时间,对端没在期限内响应看超时值和对端实际耗时;区分是连接慢还是处理慢
抛出 ConnectException目标端口没有监听,或被防火墙拒绝确认地址端口;本机用 telnet 或另一个 Socket 试连
抛出 UnknownHostException域名解析失败,不是 TCP 不通看域名拼写;在目标机器上 nslookup;检查容器 DNS 配置
运行一段时间后连接变慢、句柄上涨响应体没读完或没关闭,连接回不到池子检查 ofInputStream 是否关闭;是否只读了部分响应体
Socket 的 read 一直阻塞setSoTimeout 没设置,默认是 0,无限等待打印 getSoTimeout;连上后立刻设置读超时
读到 -1 或 null 后程序出错对端正常关闭,-1 是流结束信号,不是错误按「读到结尾」处理;不要把它当异常或空数据
中文响应乱码响应头没声明字符集,或客户端按错误字符集解码看 Content-Type;ofString 显式传 UTF_8
配了环境变量代理却不生效HttpClient 用 JVM 的 ProxySelector,不自动读环境变量检查 -Dhttp.proxyHost;显式给 Builder 设置代理
对端 301/302,客户端没跳转默认重定向策略是 NEVER看是否设置了 followRedirects;确认跳转地址是否跨域

排查网络问题,先看异常类型,再看线程栈,最后才看业务逻辑。异常类型决定大方向:超时、连接被拒、解析失败、读结束,四类问题的处理方式完全不同。线程栈能告诉你卡在哪一层,是等连接、等响应,还是等锁。

边界与代价

这两个 API 各有适用范围,越界使用会带来额外复杂度:

  • HttpClient 只管 HTTP:它不处理业务重试、熔断、限流,也不自动重试失败请求。这些要在上层自己实现,别指望客户端库代劳。
  • 阻塞式调用占线程:send 等待期间线程不能干别的。高并发下要么用 sendAsync,要么用虚拟线程,要么接受线程数上限。
  • 连接池不是无限的:池子的大小、空闲连接回收、HTTP/2 多路复用都有默认值。调优前先确认瓶颈在哪,盲目调大可能把压力推给对端。
  • TLS 配置有门槛:自定义证书、客户端认证、跳过主机名校验都需要改 SSLContext。跳过校验只适合本地调试,不能进生产。
  • Socket 是字节流:没有消息边界,没有自动重连,没有编码处理。用 Socket 就要自己定协议、处理半包、处理粘包,复杂度比 HttpClient 高一个量级。
  • 端口和句柄是有限资源:大量短连接会耗尽本地临时端口,大量未关闭的连接会耗尽文件句柄。两种耗尽的表现都是「连不上」,但排查方向完全不同。

还有一点关于超时的取舍:超时设得太短,正常的慢请求会被误杀,重试又会放大压力;设得太长,故障时线程被占住,恢复变慢。合理的做法是按接口分别设置,并记录超时发生的次数和比例。只看平均值看不出问题,尾部延迟才是关键。

选择上可以记一条简单规则:对端说的是 HTTP,就用 HttpClient;对端说的是自定义协议,或者你需要控制 TCP 的每一个字节,才用 Socket。不要用 Socket 自己拼 HTTP 报文,那等于重新实现一个不完整的客户端,边界情况会层出不穷。

当天能自己验证的练习

  1. 用 com.sun.net.httpserver.HttpServer 在本机起一个返回中文的服务,再用 HttpClient 请求,打印状态码、正文和 HTTP 版本。
  2. 让服务端故意睡 2 秒,客户端把请求超时设成 500 毫秒,记录抛出的异常类型;再把超时改成 3 秒,确认能正常返回。
  3. 建一个 ServerSocket,客户端连上后先打印 getSoTimeout(),再设置 3 秒;让服务端写完一行就关闭,观察第二次 readLine 返回 null。
  4. 用 new Socket() 加 connect(addr, 1000) 连接一个没有监听的端口,记录 ConnectException;再把主机名改成不存在的域名,对比 UnknownHostException。
  5. 把 HttpClient 的 connectTimeout 去掉、只留请求超时,思考如果目标地址根本不可达,程序会在哪一步等多久;有条件的话用一个不可达地址实测并记录。

小结

三句话收一下:HttpClient 要全局复用一个实例,连接超时和请求超时都要设,响应体必须读完或关闭;Socket 的默认读超时是 0,read 返回 -1 表示对端正常关闭;代理、重定向、DNS 缓存都有自己的默认行为,出问题时先确认默认值是不是你要的。

下一篇讲多进程:ProcessBuilder、标准输入输出和退出码。网络是「和远端进程说话」,多进程是「和本机另一个进程说话」,两者都要处理流、等待和超时;今天学到的「读结束」和「不读会卡住」,在管道上会以另一种形式出现。