1. 手机当服务器:30 并发从 30 毫秒掉到 500 毫秒,问题不在网络
在 Android Studio 里用 Java 起一个 ServerSocket,让手机临时充当 HTTP 服务端,是很常见的一类代码开发工具练手场景:同一局域网内,电脑或其他设备发一条请求,手机回一段文本。单线程压测时单次往返 30~50 毫秒,并发一到 30 个,耗时立刻涨到 150~500 毫秒——而服务端逻辑只是「收到请求、立刻返回」,根本没有数据处理。瓶颈不在网络带宽,而在连接处理模型、线程池参数,以及几个被忽略的字符与字节细节。下面按能照着做的顺序,从工程骨架、线程池调参、压测打点,一路写到这套代码最容易翻车的地方。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 代码开发工具落地:Android Studio 里 ServerSocket 的最小可跑闭环
2.1 先确认权限和线程边界,再写第一行业务代码
两个前置条件没满足,后面的代码写得再漂亮也跑不起来。第一是权限:手机要监听端口对外提供服务,必须在清单里显式声明网络权限,漏了会在 new ServerSocket(8030) 时抛 SecurityException,日志里只看到一句「无法启动服务器」,很容易误判成端口问题。
xml复制<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<!-- 监听端口、收发数据都依赖这条权限,缺了直接抛 SecurityException -->
<uses-permission android:name="android.permission.INTERNET" />
</manifest>
第二是线程边界。ServerSocket.accept() 是阻塞调用,把它放在 onCreate 或按钮回调里会立刻触发 NetworkOnMainThreadException。正确做法是让服务器继承 Thread,在 start() 之后由子线程跑 accept 循环;主线程只负责启动和销毁,不碰任何 socket 读写。
启动入口也要顺手改掉一个常见写法:按钮点击里直接 new AA_DisplayMessage().start(),点一次起一个服务器,点第二次端口就被占了。改成 Activity 持有引用、启动前判断是否还活着,并在 onDestroy 里主动释放。
java复制public class MainActivity extends AppCompatActivity {
private HttpServerThread server; // 持有引用,避免重复启动
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button start = findViewById(R.id.button_show_dialog);
start.setOnClickListener(v -> {
if (server != null && server.isAlive()) { // 已经在跑就不再起第二个
Log.d("HttpServer", "server already running");
return;
}
server = new HttpServerThread();
server.start(); // 阻塞操作全部留给子线程
});
}
@Override
protected void onDestroy() {
if (server != null) server.shutdown(); // 主动关闭,释放 8030
super.onDestroy();
}
}
这段代码没有技术含量,但它决定了后面压测数据是否可信。服务器多起一份,两个 ServerSocket 抢同一个端口,先起的那个还能跑,后起的直接失败,压测脚本连上去看到的成功率就是一半一半,很容易被当成「并发性能问题」去查,实际是自己给自己挖的坑。
2.2 ServerSocket 的开法:绑定、超时、生命周期
材料里的写法是在构造函数里 new ServerSocket(8030),异常了只打一行日志,然后 serverSocket 保持 null,run() 里判断为 null 就 return。这个写法能跑,但排查体验很差:端口被占用、权限没给、地址不可用,全都表现为同一句「无法启动服务器」。
更稳妥的做法是把「创建、绑定、循环、关闭」四个阶段拆开,每一步失败都有独立日志,并且给 socket 加上两个关键选项。
java复制public class HttpServerThread extends Thread {
private static final String TAG = "HttpServer";
private static final int PORT = 8030; // 与客户端约定的端口
private static final int POOL_SIZE = 4; // 先给小值,压测后再按 p95 调
private final ExecutorService pool = Executors.newFixedThreadPool(POOL_SIZE);
private volatile boolean running = true;
private ServerSocket serverSocket;
@Override
public void run() {
try {
serverSocket = new ServerSocket();
// 关闭后端口可能还处于 TIME_WAIT,复用地址能避免重启时的 BindException
serverSocket.setReuseAddress(true);
serverSocket.bind(new InetSocketAddress(PORT));
Log.d(TAG, "listening on " + PORT);
while (running && !serverSocket.isClosed()) {
Socket client = serverSocket.accept(); // 这一行只做「收连接」
client.setSoTimeout(3000); // 单连接 3 秒没有任何进展就放弃
pool.execute(() -> handle(client)); // 读写交给线程池
}
} catch (IOException e) {
Log.e(TAG, "server loop exit: " + e.getMessage());
}
}
public void shutdown() {
running = false;
try {
if (serverSocket != null) serverSocket.close(); // 让 accept 抛异常退出
} catch (IOException ignored) {
}
pool.shutdownNow();
}
}
setReuseAddress(true) 解决的是「App 杀掉重开、端口还在 TIME_WAIT」这类重启失败;setSoTimeout(3000) 解决的是「客户端连上但不发数据」把处理线程永久占住。这两个参数都必须在 accept 返回的 Socket 上设置,而不是只设置在 ServerSocket 上——监听套接字的选项不会自动继承给已建立的连接。
POOL_SIZE 这里先写 4,不是拍脑袋。手机 SoC 常见只有几个大核参与调度,30 个并发连接如果对应 30 个阻塞线程,线程数远超可用核心数,切换开销会直接把响应时间拉长。先用小池子跑基线,再根据压测的排队情况往上加,比一上来写 50 更容易看清问题出在哪。
2.3 一次请求的读写闭环:头、体、响应
连接拿到之后,处理逻辑就是标准的 HTTP 一来一回:读到空行为止解析请求头,按 Content-Length 读请求体,然后写状态行、响应头、空行、响应体。材料里的骨架是对的,问题集中在字符集、长度计算和异常处理三处。
java复制private void handle(Socket client) {
long t0 = SystemClock.elapsedRealtime();
try (Socket s = client;
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
// HTTP 头是 ASCII,显式指定编码,避免依赖平台默认值
BufferedReader reader = new BufferedReader(
new InputStreamReader(in, StandardCharsets.US_ASCII), 4096)) {
String requestLine = reader.readLine(); // 第一行含方法、路径、版本
if (requestLine == null) return;
int contentLength = 0;
String line;
while ((line = reader.readLine()) != null && !line.isEmpty()) {
// 头名大小写不敏感,不能用 startsWith 精确匹配
if (line.regionMatches(true, 0, "Content-Length:", 0, 15)) {
contentLength = Integer.parseInt(line.substring(15).trim());
}
}
String requestBody = "";
if (contentLength > 0) {
// 仅当请求体是 ASCII 时字符数才等于字节数,中文或二进制要改成按字节读
char[] buf = new char[contentLength];
int read = 0;
while (read < contentLength) {
int n = reader.read(buf, read, contentLength - read);
if (n < 0) break;
read += n;
}
requestBody = new String(buf, 0, read);
}
// Content-Length 必须是字节数,中文一个字在 UTF-8 里占 3 字节
byte[] payload = "请求成功".getBytes(StandardCharsets.UTF_8);
String head = "HTTP/1.1 200 OK\r\n"
+ "Content-Type: text/plain; charset=utf-8\r\n"
+ "Content-Length: " + payload.length + "\r\n"
+ "Connection: close\r\n"
+ "\r\n";
out.write(head.getBytes(StandardCharsets.US_ASCII));
out.write(payload);
out.flush();
Log.d(TAG, "handle cost=" + (SystemClock.elapsedRealtime() - t0) + "ms");
} catch (IOException e) {
Log.w(TAG, "handle failed: " + e.getMessage());
}
}
几个参数值得单独说明。requestLine 只用来判断请求是否完整,不做业务路由,所以没必要把整包数据拼成一个 StringBuilder 再整体解码;regionMatches(true, ...) 的 true 表示忽略大小写,因为不同客户端发出的头名大小写并不统一;payload.length 取的是字节数组长度而不是 String.length(),后者返回的是 UTF-16 码元个数,「请求成功」四个字算出来是 4,实际发出去是 12 字节;Connection: close 明确告诉客户端这条连接用完即关,避免 HTTP/1.1 默认长连接导致客户端一直挂着等下一段数据。
shutdown() 里的 pool.shutdownNow() 和 finally 里的 client.close() 是配套的。只关 ServerSocket 而不关线程池,已经提交的任务还会继续跑,进程里残留一批阻塞在 readLine 上的线程;只关线程池而不关监听套接字,accept 还在原地等着下一个连接进来。
3. 代码开发工具调参:50 个线程为什么救不了 30 并发
3.1 accept 单线程不等于处理单线程
很多人看到「30 并发要 30 个线程同时处理」就本能地把线程池开到 50,然后发现并发一上来耗时反而更离谱。原因是 accept 循环和处理任务是两件完全不同的事:accept 只负责把三次握手完成的连接从内核队列里取出来,它永远是单线程的,业务处理才是多线程的。
这个分工决定了 accept 循环里不能有任何耗时操作。把 new BufferedReader、日志字符串拼接、URLDecoder.decode 全部塞进 accept 之后的同步路径上,等于让所有新连接排成一队做同样的准备工作,并发越高排队越长。材料里的代码其实已经用线程池把处理甩出去了,但有个细节容易被忽略:threadPool.execute(...) 本身在主循环里执行,如果池子满了、任务队列也满了,execute 的拒绝策略是抛 RejectedExecutionException,而 newFixedThreadPool 用的是无界队列,任务会一直堆着,accept 不阻塞但响应时间会线性变差。
区分这两件事的办法很简单:在 accept 返回后立刻打一个时间戳,在处理线程开头再打一个,两个时间戳的差值就是「排队时间」。这个值如果随着并发升高而变大,说明瓶颈在线程池;如果一直很小而总耗时很大,问题在处理逻辑本身。
3.2 线程池大小:4、8、50 三种取值各自的代价
线程池大小不是越大越好,也不是套公式能算出来的。手机端的约束比服务器更硬:可用核心数少、内存带宽有限、每个线程都有独立的栈空间,30 个线程同时驻留光是内存占用就不小。下面这张表是实际调参时最常遇到的三种取值。
| POOL_SIZE | 适用场景 | 代价 |
|---|---|---|
| 2~4 | 少量设备定时轮询、单次请求处理在 10ms 以内 | 并发数超过池大小时请求排队,p95 明显抬高 |
| 8 | 十几个客户端短连接、处理逻辑以读写为主 | 排队可控,CPU 占用平稳 |
| 50 | 想硬扛 30 并发峰值 | 线程数远超可用核心数,上下文切换开销上来,GC 压力增大 |
判断该往哪个方向调,看压测结果里的两个数:最小耗时和最大耗时。如果最小耗时稳定在 30~50 毫秒,说明单个连接的处理路径没问题,最大耗时涨到 500 毫秒纯粹是排队;这时候把 POOL_SIZE 从 4 加到 8,看 p95 是否下降,下降就继续加一档,加到不再下降为止。如果最小耗时本身就超过 100 毫秒,加线程池没有意义,得回头查处理逻辑里是不是有阻塞调用。
还有一个容易被忽略的点:线程池是 HttpServerThread 的实例字段,每次 new HttpServerThread() 都会新建一个池子。前面 2.1 已经改掉了重复启动,但如果代码里还有其他地方 new 了服务器实例,旧池子的线程不会自动回收,表现为「服务器只启动了一次,线程数却越用越多」。
3.3 把单个连接的工作量压到最小
并发上不去,往往不是线程不够,而是每个连接干的活太多。按影响从大到小排,最值得砍的是三样。
第一是日志。Log.d 在 Android 上是跨进程写入 logcat 的,每条都有固定开销,每秒几十条还能接受,几百条就开始拖慢处理线程。压测阶段保留「处理耗时超过阈值才打」的日志,正常路径不打,可以显著减少干扰。
第二是字符串处理。整个请求头拼成 StringBuilder 再整体 URLDecoder.decode,在只需要判断请求是否完整的场景下完全是浪费;请求头里出现 % 和 + 的行(比如 URL 编码过的参数)还会被错误改写。正确做法是只在需要解析 query 或 body 的地方做解码,头本身按原样读。
第三是对象创建。每个连接创建一个 BufferedReader 是必要的,但没必要每个连接再创建一个 byte[]、一个 StringBuilder、一个解码后的大字符串。缓冲区大小给 4KB 就够读一个典型的 HTTP 头,给到 64KB 只会让 30 个并发连接占掉更多内存,触发更频繁的 GC。
4. 压测与量化:把 150~500 毫秒拆成可观察的几段
4.1 用局域网脚本复现单线程与 30 并发
先把「30~50 毫秒」和「150~500 毫秒」这两组数据在自己的环境里复现出来,否则后面调什么参数都是盲调。压测脚本跑在电脑上,手机和电脑连同一个局域网,脚本里填手机的实际地址。
python复制import socket
import time
import concurrent.futures
HOST = "192.168.1.20" # 换成手机在局域网里的地址
PORT = 8030
def once(_):
t0 = time.perf_counter()
with socket.create_connection((HOST, PORT), timeout=5) as s:
s.sendall(b"GET /ping HTTP/1.1\r\nHost: phone\r\nConnection: close\r\n\r\n")
data = b""
while True:
chunk = s.recv(4096)
if not chunk: # 服务端关连接后 recv 返回空,说明响应收完了
break
data += chunk
return (time.perf_counter() - t0) * 1000
for n in (1, 30):
with concurrent.futures.ThreadPoolExecutor(max_workers=n) as ex:
costs = list(ex.map(once, range(n)))
costs.sort()
p50 = costs[len(costs) // 2]
print(f"并发 {n}: min={costs[0]:.1f}ms p50={p50:.1f}ms max={costs[-1]:.1f}ms")
脚本里的关键点是 Connection: close 和服务端的 Connection: close 必须对应。如果客户端发了长连接请求、服务端却直接关连接,recv 会提前返回空,测出来的耗时偏小;反过来如果服务端不关、客户端又等,就会一直卡到超时,测出来的耗时全是 5 秒。ThreadPoolExecutor(max_workers=n) 的 n 就是并发数,跑 1 和 30 两轮,是为了拿到「基线」和「并发」两组对照。
这里要提醒一句:脚本跑出来的绝对值受电脑性能、Wi-Fi 信道、手机省电策略影响,不同机器上数字会差不少,但「单线程 30~50 毫秒、30 并发 150~500 毫秒」这个比例的成因是一致的。别纠结绝对值,重点看并发前后最小耗时是否有变化。
4.2 在 Logcat 里打点:排队、读头、写响应各占多少
外部压测只能看到总耗时,要看清楚时间花在哪,得在服务端加打点。用 SystemClock.elapsedRealtime() 而不是 System.currentTimeMillis(),前者不受系统时间调整影响,量的是真实流逝时间。
java复制long tAccept = SystemClock.elapsedRealtime(); // accept 返回那一刻
pool.execute(() -> {
long tStart = SystemClock.elapsedRealtime(); // 线程真正开始跑
// ... 读头、读体、写响应 ...
long tEnd = SystemClock.elapsedRealtime();
Log.d(TAG, "queue=" + (tStart - tAccept)
+ "ms total=" + (tEnd - tStart) + "ms");
});
三个数字读法不同。tStart - tAccept 是排队时间,它随并发升高而变大,说明线程池不够用;tEnd - tStart 是处理时间,它稳定在很小的值,说明服务端逻辑没问题。外面测到的总耗时 ≈ 网络往返 + 排队时间 + 处理时间。单线程时排队时间接近 0,总耗时基本就是网络往返;30 并发时如果排队时间占了 100 毫秒以上,那 150~500 毫秒的波动就有了解释。
日志用命令行过滤,比在 Android Studio 的 Logcat 面板里翻要快:
bash复制adb logcat -s HttpServer:D
压测开着,盯着 queue= 这个字段看几十条,就能判断该调线程池还是该查处理逻辑。
4.3 结果怎么读:四种典型现象对应的方向
拿到数据之后,别急着改代码,先对号入座。下面这四种现象在手机端 HTTP 服务上最常出现,对应的方向完全不同。
| 现象 | 大概率原因 | 下一步 |
|---|---|---|
| 单线程就 30~50ms,30 并发 min 仍是 30ms、max 到 500ms | 排队,线程池偏小或处理路径有阻塞 | 先看排队时间,再考虑加池子 |
| 30 并发 min 也涨到 150ms 以上 | 处理逻辑本身变慢,可能是 GC 或日志 | 关掉正常路径日志后重测 |
| 偶尔出现 3 秒整的耗时 | 命中了 setSoTimeout 的超时值 |
查客户端是否连上不发数据 |
| 成功率不到 100%,日志里有 BindException | 服务器实例起了不止一个 | 回到启动入口做单例判断 |
第二行最容易被误判成线程不够,实际是每个连接都在创建大对象触发 GC。判断方法很简单:把 Log.d 全部注释掉再压一轮,如果 min 掉回 30 毫秒,就是日志和字符串拼接的锅。
5. 避坑排查:这套代码里五个会直接翻车的点
5.1 每点一次按钮就起一个服务器,第二次直接 BindException
现象:第一次点按钮正常,第二次点击后日志里出现 EADDRINUSE (Address already in use),但界面上没有任何提示,看起来像「服务器卡住了」。
原因:按钮回调里 new AA_DisplayMessage().start(),每点一次就新建一个实例,构造函数里又直接 new ServerSocket(8030),端口已经被第一个实例占着,第二个必然失败。更麻烦的是构造函数捕获了 IOException 之后只打了日志,serverSocket 保持 null,run() 里判断为 null 直接 return,整个失败过程没有任何回传。
解决:把服务器实例提到 Activity 字段,启动前判断 isAlive();构造和绑定拆到 run() 里做,失败时用 Log.e 打出具体异常;onDestroy 里调 shutdown() 主动释放端口。如果业务上确实需要多次启停,还要配上 setReuseAddress(true),否则关掉之后端口在 TIME_WAIT 状态下仍然绑不上。
5.2 字符与字节混用:响应被截断、请求体被吃掉
现象:客户端收到的响应只有一两个乱码字符,或者 curl 一直挂到超时;带中文的请求体读出来是乱码,长度也不对。
原因有两个,都在同一个根上。响应头里写 "Content-Length: " + ret.length(),ret 是 "请求成功" 这个 String,length() 返回 4,但 UTF-8 编码后是 12 字节,客户端按 4 字节截断,剩下的字节要么被丢掉,要么被当成下一条响应。请求体那边用 char[] bodyChars = new char[contentLength] 按字节数申请字符数组,再 reader.read 按字符读,contentLength 和实际字符数不相等,读多读少都可能。
解决:响应体的长度一律用 payload.length(字节数组),并且 Content-Type 里显式写 charset=utf-8;请求体如果要支持非 ASCII,就别用 BufferedReader 的字符读法,改成从 InputStream 按字节读满 contentLength。改完拿一条带中文的请求测一遍,服务端日志里打出的字节数和客户端收到的字节数应该一致。
5.3 把整个请求头丢进 URLDecoder,异常和数据改写一起来
现象:某些请求进来后 handleClientConnection 直接抛异常退出,客户端收不到任何响应;或者请求参数里的 + 变成了空格,路径里的 %2F 被还原成 /。
原因:材料里 params = URLDecoder.decode(params, "UTF-8") 作用在整个请求头字符串上,而请求头里包含请求行、Host、User-Agent 等各种字段。URLDecoder 遇到孤立的 % 或者 % 后面不是合法十六进制字符会抛 IllegalArgumentException,这个异常不是 IOException,捕获不到就直接冲出方法;同时 URLDecoder 按表单编码规则处理,会把 + 解码成空格,把本应保留的编码字符改写掉。
解决:只对真正需要解码的片段调用 URLDecoder。query 从请求行里按 ? 切开后单独解,body 按 Content-Type 判断是不是 application/x-www-form-urlencoded 再解,请求头和路径原样保留。解码失败要单独 catch IllegalArgumentException,回 400,而不是让线程带着异常退出。
5.4 没设 soTimeout,finally 里再抛 RuntimeException,线程被拖死
现象:服务器运行一段时间后不再响应新请求,日志里也没有明显报错;或者压测到一半,线程池里的任务全部卡住,accept 还在正常接收连接。
原因有两个叠加。一是连接没有 setSoTimeout,客户端连上之后不发数据或者发一半断开,处理线程就永久阻塞在 readLine 上,线程池的线程被逐个占满,后面排队的任务永远轮不到。二是 finally 块里 clientSocket.close() 失败时 throw new RuntimeException(e),这个异常在 pool.execute 提交的 Runnable 里抛出,线程池不会打印堆栈,异常被静默吞掉,一个线程就这么没了。
解决:在 accept 返回后立刻 client.setSoTimeout(3000),让阻塞读有上限;finally 里的 close() 用 try/catch 包住只打日志,绝不再抛异常;线程池提交任务时给 Runnable 整体套一层 try/catch(Throwable),保证任何异常都能落到日志里。
5.5 没有 reuseAddress、退出时不 close,重启全靠运气
现象:改完代码重新安装 App,连不上;过一会儿再试又好了。或者杀掉进程再打开,第一个请求必然失败。
原因:没有 setReuseAddress(true),上一次运行残留的连接处于 TIME_WAIT 状态,端口在操作系统层面还没释放;onDestroy 里也没有调用 shutdown(),ServerSocket 和线程池都靠进程退出被动回收,退出时机不确定。
解决:ServerSocket 创建后先 setReuseAddress(true) 再 bind;shutdown() 里先置 running = false,再 serverSocket.close() 让阻塞的 accept 抛异常退出,最后 pool.shutdownNow()。改完之后连续做五次「杀掉进程、重开、立刻发请求」,都能一次连上,才算过关。
5.6 从现象反推的排查顺序
五个坑里有一半的表现都是「客户端收不到响应」,靠猜效率很低。按下面的顺序走一遍,基本能在几分钟内定位。
先看成功率:有请求失败就先查服务器实例是不是起了多个,日志里搜 EADDRINUSE。再看耗时分布:最小耗时正常、最大耗时很大,查排队时间和线程池;最小耗时也大,查日志和对象创建。最后看异常:IllegalArgumentException 指向解码位置,SocketTimeoutException 指向客户端不发数据,RuntimeException 指向 finally 里的关闭逻辑。
6. 收尾技巧:字符集、连接关闭和一次可复现的验收
这套代码写到能跑不难,难的是让它在 30 并发下稳定。我最后收敛到三条固定习惯,每次新建这类服务都照做一遍。
第一条,编码全部显式指定。请求头按 US-ASCII 读,响应体按 UTF-8 写,Content-Type 里带上 charset=utf-8,Content-Length 一律用字节数组长度。不写默认值,是因为默认值随平台和 API 版本变,出问题时极难复现。
第二条,连接生命周期写死。accept 之后立刻设 setSoTimeout,处理完立刻 close,响应头带 Connection: close。短连接模型在手机端比长连接省心得多,不需要维护连接状态,也不会因为客户端异常断开留下半开连接。吞吐确实会低一些,但对这种临时服务场景完全够用。
第三条,验收用固定脚本,不靠手动点按钮。
| 验收项 | 操作 | 通过标准 |
|---|---|---|
| 端口可复用 | 连续启动、关闭服务器 5 次 | 每次都成功绑定,日志无 EADDRINUSE |
| 超时生效 | 用 nc 连上端口后不发数据 |
3 秒后服务端日志出现超时并释放线程 |
| 中文响应完整 | 请求一次返回中文的接口 | 客户端收到的字节数与 Content-Length 一致 |
| 并发基线 | 脚本跑 1 并发和 30 并发 | 30 并发 p50 不超过单线程的 3 倍 |
这套流程是我踩过一次大坑之后固化下来的:当时压测数据一直上不去,查了半天线程池参数,最后发现是响应头里的 Content-Length 少算了八个字节,客户端一直在等剩下的数据,超时后才断开。从那以后,我每次写这类手机端服务,都先把「长度按字节算、连接显式关、超时必须有」这三件事过一遍,再去动线程池。希望帮到你。
