一、什么是 Streaming?
Streaming(流式响应)是一种将数据分块、持续传输给客户端的通信机制。
在传统非流式响应(Non-streaming)模式下,服务端通常需要等待模型完成整个回答,再将完整结果返回给客户端。
例如,用户提出:
请解释 Transformer 的工作原理。
模型可能需要生成数百甚至数千个 Token。非流式模式下,用户可能需要等待整个回答生成完成才能看到内容。
Streaming 则不同。
模型每生成一部分内容,服务端就可以将其发送给客户端,客户端持续接收并展示。
两种模式的主要区别:
| 对比维度 | 非流式响应 | 流式响应 |
|---|---|---|
| 返回方式 | 一次性返回完整结果 | 分块持续返回 |
| 首次可见内容 | 通常需要等待完整生成 | 可以提前展示 |
| 用户体验 | 容易产生长时间等待感 | 更接近实时交互 |
| 连接状态 | 请求完成后结束 | 生成期间保持连接 |
| 数据处理 | 一次性解析 | 持续解析和累积 |
| 适用场景 | 短文本、批处理 | 对话、长文本、实时交互 |
需要区分两个概念:
- 模型生成: 模型逐步预测并生成 Token。
- Streaming 传输: 服务端将已经生成的内容分块发送给客户端。
模型内部逐 Token 生成,并不意味着网络必须逐 Token 发送。服务端可以对多个 Token 进行缓冲和合并,再组成一个数据块传输。
二、Streaming 的整体工作流程
一个典型的大模型流式响应系统包含客户端、应用服务、模型推理服务和网络传输层。
flowchart TD
A["用户提交请求"] --> B["客户端发起 HTTP 请求"]
B --> C["应用服务接收请求"]
C --> D["调用模型推理服务"]
D --> E["模型执行 Prefill"]
E --> F["模型逐步 Decode"]
F --> G["生成新的 Token"]
G --> H["服务端组织响应数据块"]
H --> I["通过流式连接发送"]
I --> J["客户端接收数据块"]
J --> K["解析并更新界面"]
K --> L{"生成是否完成"}
L -->|"否"| F
L -->|"是"| M["发送结束事件"]
M --> N["关闭流式连接"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#EAF3EC,stroke:#83A995,color:#315D49
style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style M fill:#EAF3EC,stroke:#83A995,color:#315D49
style N fill:#DCEFE5,stroke:#4F8B70,color:#24563F
整个过程可以分为几个关键阶段:
- 建立连接: 客户端向服务端发起流式请求。
- 模型推理: 模型处理输入并开始生成内容。
- 数据分块: 服务端将生成内容封装为一个或多个数据块。
- 持续传输: 数据块通过网络连接持续发送。
- 客户端解析: 客户端解析数据块并更新界面。
- 结束处理: 模型完成生成,服务端发送结束标记并关闭连接。
Streaming 并不会改变模型的核心生成算法,它主要改变的是推理结果的交付方式。
三、Streaming 与 Token 生成机制
理解 Streaming,需要先理解大语言模型的自回归生成机制。
1. 模型逐 Token 生成
以 Decoder-only Transformer 为例,模型根据已有上下文预测下一个 Token。
假设用户输入:
人工智能的发展方向是
模型可能依次生成:
多模态
融合
与
智能体
应用
。
其生成过程可以抽象为:
flowchart TD
A["输入 Prompt"] --> B["Transformer 计算"]
B --> C["生成下一个 Token"]
C --> D["将 Token 加入上下文"]
D --> E{"是否满足停止条件"}
E -->|"否"| B
E -->|"是"| F["完成生成"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
每轮 Decode 通常生成一个新的 Token,然后将其加入后续生成所使用的上下文。
在实际推理中,模型还会结合 KV Cache 复用历史计算结果,避免重复计算历史 Token 的 Key 和 Value。
2. Token 不等于字符
一个 Token 可能对应:
- 一个完整单词。
- 一个汉字。
- 多个字符。
- 一个词语片段。
- 标点符号。
- 特殊控制标记。
例如,下面的文本:
Streaming 流式响应
可能被切分为多个 Token,而不是按照空格或字符逐个生成。
因此,Streaming 中的一个数据块不一定对应一个完整单词,也不一定对应一个完整句子。
3. Token 生成与网络传输不是一回事
这是理解 Streaming 时最容易出现的误区。
模型可以逐 Token 生成,但推理服务通常不会保证每生成一个 Token 就立即发送一次网络数据。
原因包括:
- 网络传输存在固定开销。
- 多次小数据包可能降低传输效率。
- 服务端可能进行缓冲。
- 推理框架可能批量处理输出。
- 网关、代理和客户端可能进一步缓冲数据。
例如,模型连续生成:
人工
智能
正在
改变
软件
开发
。
服务端可能将这些 Token 合并为:
人工智能正在改变软件开发。
再发送给客户端。
因此:
Token 是模型生成的基本单位,Chunk 是流式传输的数据单位,两者并不等价。
四、Streaming 的核心传输机制
Streaming 不只是模型输出方式,还涉及应用协议、网络传输和客户端解析。
常见实现方式包括:
- HTTP Chunked Transfer Encoding。
- Server-Sent Events(SSE)。
- WebSocket。
- 基于 HTTP 的其他流式传输协议。
这些技术所处层次不同,不能简单认为它们是同一种协议。
1. HTTP Chunked Transfer Encoding
HTTP Chunked Transfer Encoding 是 HTTP/1.1 中的一种分块传输编码机制。
在传统 HTTP 响应中,服务端通常可以通过 Content-Length 指定响应体的完整长度。
但对于动态生成的内容,服务端在生成开始时往往无法确定最终响应体长度。
Chunked Transfer Encoding 允许服务端将响应体拆分为多个数据块逐步发送,而不需要预先知道完整长度。
示意:
HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked
5
Hello
6
World
0
这里:
- 每个数据块前面包含该块的十六进制字节长度。
5表示后续数据块包含 5 个字节。6表示后续数据块包含 6 个字节。0表示响应体传输结束。
需要注意:
HTTP/1.1 的 Chunked Transfer Encoding 是一种传输编码机制,不等于 SSE。
HTTP/2 不使用 HTTP/1.1 的 Transfer-Encoding: chunked 机制,而是通过 HTTP/2 DATA Frames 承载响应数据。
HTTP/3 则基于 QUIC 传输数据。
应用层的流式响应逻辑可以保持相似,但底层传输方式可能不同。
2. Server-Sent Events(SSE)
SSE 是一种基于 HTTP 的服务器向客户端单向推送事件的机制。
在大模型应用中,SSE 是非常常见的流式响应实现方式。
典型响应头:
HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive
SSE 使用特定的文本格式组织事件。
例如:
data: {"content":"人工智能"}
data: {"content":"正在改变"}
data: {"content":"软件开发"}
data: [DONE]
每个事件通常以空行结束。
SSE 支持的常见字段包括:
| 字段 | 作用 |
|---|---|
data |
事件数据 |
event |
事件类型 |
id |
事件标识 |
retry |
建议客户端重连等待时间 |
例如:
event: message
id: 101
data: {"content":"Hello"}
客户端可以通过浏览器的 EventSource 接口接收 SSE 事件。
不过,原生 EventSource 主要适用于 GET 请求,且不能自由设置任意请求头。
如果大模型 API 需要通过 POST 发送复杂 JSON 请求,前端通常使用 fetch() 读取响应流,或者通过后端代理完成 SSE 转发。
3. WebSocket
WebSocket 是一种支持双向通信的网络协议。
与 SSE 不同,WebSocket 建立连接后,客户端和服务端都可以主动发送消息。
典型交互:
flowchart TD
A["客户端发起连接请求"] --> B["HTTP Upgrade 握手"]
B --> C["建立 WebSocket 连接"]
C --> D["客户端发送消息"]
D --> E["服务端处理请求"]
E --> F["服务端发送流式数据"]
F --> G["客户端持续接收"]
G --> H{"是否需要继续交互"}
H -->|"是"| D
H -->|"否"| I["关闭 WebSocket 连接"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style I fill:#E5F0E9,stroke:#83A995,color:#315D49
WebSocket 更适合:
- 实时语音交互。
- 双向实时通信。
- 多轮持续交互。
- 需要客户端随时发送控制消息的场景。
- 实时状态同步。
但 WebSocket 并不是大模型流式响应的必选方案。
对于普通文本生成,HTTP SSE 通常已经足够。
4. SSE 与 WebSocket 的区别
| 对比维度 | SSE | WebSocket |
|---|---|---|
| 通信方向 | 服务端向客户端单向推送 | 双向通信 |
| 底层基础 | HTTP | WebSocket 协议 |
| 数据格式 | UTF-8 文本事件 | 文本或二进制消息 |
| 连接方式 | HTTP 长连接 | Upgrade 握手后建立连接 |
| 自动重连 | 浏览器 EventSource 支持 | 通常需要应用层实现 |
| 复杂度 | 相对简单 | 相对复杂 |
| 典型场景 | 文本流式响应 | 实时双向交互 |
选择时不应简单认为 WebSocket 一定比 SSE 更快。
真正影响延迟的因素还包括模型推理速度、网络质量、服务端缓冲、代理配置和客户端处理能力。
五、Streaming 的服务端实现
服务端需要完成三个核心任务:
- 接收模型生成的数据。
- 将数据转换为流式响应格式。
- 持续写入 HTTP 响应。
以 Python 为例,可以使用 FastAPI 构建一个简化的 SSE 服务。
1. 基础 SSE 服务
import asyncio
import json
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
app = FastAPI()
async def generate_text():
tokens = [
"Streaming",
" 是",
" 一种",
" 流式",
"响应",
"机制",
"。"
]
for token in tokens:
event = {
"content": token
}
yield f"data: {json.dumps(event, ensure_ascii=False)}\n\n"
await asyncio.sleep(0.2)
yield "data: [DONE]\n\n"
@app.get("/stream")
async def stream():
return StreamingResponse(
generate_text(),
media_type="text/event-stream",
headers={
"Cache-Control": "no-cache",
"X-Accel-Buffering": "no"
}
)
这里的 generate_text() 是一个异步生成器。
每次执行 yield,都会向响应流提供一段数据。
StreamingResponse 负责将这些数据持续发送给客户端。
几个关键点:
async def:定义异步函数。yield:逐步产生响应数据。text/event-stream:声明 SSE 内容类型。\n\n:标记一个 SSE 事件结束。X-Accel-Buffering: no:在使用 Nginx 时,可用于关闭该响应的代理缓冲。
示例中的 asyncio.sleep() 仅用于模拟 Token 生成间隔,真实系统应当消费模型推理服务产生的流。
2. 接入真实模型推理服务
真实项目中,服务端通常需要调用模型 API,并将模型返回的流式数据转发给前端。
整体结构:
flowchart TD
A["前端请求"] --> B["FastAPI 服务"]
B --> C["调用模型 API"]
C --> D["接收模型 Stream"]
D --> E["解析模型事件"]
E --> F["提取文本或结构化内容"]
F --> G["封装为 SSE 事件"]
G --> H["持续发送给前端"]
H --> I["前端解析并展示"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
生产环境中还需要处理:
- 模型 API 的连接超时。
- 客户端断开后的资源释放。
- 模型生成异常。
- 代理层缓冲。
- 多轮对话的请求状态。
- 结束事件和错误事件。
- 客户端取消请求后的推理任务终止。
特别需要注意:客户端断开连接,不代表模型推理服务一定会自动停止生成。应用程序需要将取消信号传递给底层模型请求,避免无意义地继续消耗 GPU 资源。
六、客户端如何接收 Streaming 数据?
服务端负责持续发送,客户端则需要持续读取、解析和更新页面。
1. 使用 Fetch 读取响应流
浏览器的 fetch() 可以通过 ReadableStream 读取 HTTP 响应体。
简化示例:
async function streamResponse() {
const response = await fetch("/stream");
if (!response.ok) {
throw new Error("请求失败");
}
if (!response.body) {
throw new Error("浏览器不支持响应流");
}
const reader = response.body.getReader();
const decoder = new TextDecoder();
let buffer = "";
while (true) {
const { value, done } = await reader.read();
if (done) {
break;
}
buffer += decoder.decode(value, {
stream: true
});
const events = buffer.split("\n\n");
buffer = events.pop() ?? "";
for (const event of events) {
const dataLine = event
.split("\n")
.find(line => line.startsWith("data:"));
if (!dataLine) {
continue;
}
const data = dataLine.slice(5).trim();
if (data === "[DONE]") {
return;
}
const result = JSON.parse(data);
console.log(result.content);
}
}
buffer += decoder.decode();
if (buffer.trim()) {
// 根据实际协议处理最后一个未完成事件
}
}
这里涉及几个重要 API:
| API | 作用 |
|---|---|
response.body |
获取响应体流 |
getReader() |
获取流读取器 |
reader.read() |
读取下一个数据块 |
TextDecoder |
将字节解码为文本 |
decode() |
解码字节数据 |
stream: true |
保留不完整字符的解码状态 |
2. 为什么需要 buffer?
这是 Streaming 客户端开发中非常容易出错的地方。
网络传输的数据块与 SSE 事件并不一定一一对应。
例如,服务端发送:
data: {"content":"Hello"}
data: {"content":"World"}
客户端可能收到以下任意形式:
情况一:一次收到完整事件
data: {"content":"Hello"}
情况二:一次收到多个事件
data: {"content":"Hello"}
data: {"content":"World"}
情况三:一个事件被拆成多个数据块
第一次:
data: {"cont
第二次:
ent":"Hello"}
如果客户端每次 reader.read() 后都直接解析 JSON,就可能出现解析失败。
因为 read() 返回的是传输数据块,不保证对应完整的 SSE 事件,更不保证对应完整的 JSON 对象。
正确处理方式是:
- 将新数据追加到缓冲区。
- 按 SSE 事件分隔符寻找完整事件。
- 只解析已经完整接收的事件。
- 保留最后一个不完整片段。
- 等待后续数据继续拼接。
需要注意,真实 SSE 解析器还应正确处理 event、id、多行 data、注释行、CRLF 换行以及流结束时尚未完整分隔的最后一个事件。
生产环境优先使用经过验证的 SSE 解析库,而不是长期依赖简化的字符串切分逻辑。
3. TextDecoder 为什么需要 stream 模式?
网络传输的是字节,而不是天然完整的 UTF-8 字符。
一个中文字符可能由多个 UTF-8 字节组成。
假设某个字符的字节序列被网络分成两部分:
数据块 A:字符的前两个字节
数据块 B:字符剩余的一个字节
如果每次都独立解码,第一块可能因为字符不完整而产生替换字符。
使用:
decoder.decode(value, {
stream: true
});
可以让解码器保留尚未完成的字符字节,等待后续数据到达。
因此,Streaming 客户端需要同时处理两类边界:
- UTF-8 字符边界。
- SSE 事件边界。
它们不是同一层面的边界,不能混为一谈。
七、Streaming 与 Prefill、Decode 的关系
Streaming 是传输层的机制,而 Prefill 和 Decode 是大模型推理过程中的计算阶段。
两者属于不同层次,但密切相关。
1. Prefill 阶段
Prefill 负责处理完整输入 Prompt。
主要工作包括:
- Tokenizer 编码。
- Embedding 映射。
- Transformer 层计算。
- 生成 Prompt 对应的 KV Cache。
- 计算第一个输出 Token 的预测分布。
Prefill 通常需要处理整个输入序列,因此它的计算量与 Prompt 长度密切相关。
在一般的自回归生成流程中,模型需要完成 Prefill,才能开始生成第一个输出 Token。
2. Decode 阶段
Decode 负责逐步生成后续 Token。
每轮 Decode 通常会:
- 输入当前需要处理的新 Token。
- 读取历史 KV Cache。
- 执行 Transformer 计算。
- 生成下一个 Token。
- 更新 KV Cache。
Decode 阶段是流式文本内容的主要来源。
3. Streaming 与推理阶段的对应关系
flowchart TD
A["用户提交 Prompt"] --> B["Tokenizer 编码"]
B --> C["Prefill 阶段"]
C --> D["建立 KV Cache"]
D --> E["计算首个输出 Token"]
E --> F["服务端发送首批数据"]
F --> G["Decode 阶段"]
G --> H["生成后续 Token"]
H --> I["服务端持续发送数据"]
I --> J["客户端持续展示"]
J --> K{"是否生成结束"}
K -->|"否"| G
K -->|"是"| L["结束流式响应"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
需要注意一个细节:
Prefill 并不一定意味着用户必须等待整个 Prompt 的所有计算完成后才看到任何响应元数据。服务端可以提前发送响应头、状态事件或进度信息。
但对于通常的自回归文本生成,真正的首个生成 Token 仍需要模型完成必要的 Prefill 计算。
八、Streaming 的关键性能指标
评价流式响应性能,不能只看整个请求的总耗时。
需要分别观察模型推理速度、首个内容到达时间和网络传输表现。
1. TTFT:Time To First Token
TTFT 表示从请求开始到客户端收到第一个生成 Token 所经过的时间。
可以抽象为:
TTFT 通常包含: