---
title: "大模型延迟详解：TTFT、tokens/s 与端到端延迟 | BroadRouter"
description: "首 token 延迟（TTFT）、每秒 token 数和端到端延迟各自衡量什么，怎样用代码在客户端测量，以及哪种优化能改善哪个数字。"
url: https://broadrouter.com/zh/blog/llm-latency-ttft-throughput/
lang: zh-Hans
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

本页由英文原文借助 AI 翻译。[阅读英文原文](https://broadrouter.com/blog/llm-latency-ttft-throughput/)（2026-11-16 更新）。

# 大模型延迟：首 token 延迟、每秒 token 数与端到端耗时

BroadNet Inference 团队 · 阅读约 4 分钟 · 发布于 2026-11-14 · 更新于 2026-11-16

首 token 延迟（TTFT）是收到第一个输出 token 之前的等待时间；每秒 token 数是之后回答流式输出的速度；端到端延迟是总耗时，即 TTFT 加上生成时间（约为输出 token 数除以单用户速度）。提示词长度和排队决定 TTFT，模型大小和负载决定速度，回答长度决定总耗时。三者都要按 p50 和 p95 测量。

## 要点

-   端到端延迟 ≈ TTFT +（输出 token 数 − 1）× token 间延迟，约等于 TTFT + 输出 token 数 ÷ 单用户每秒 token 数。回答长时，速度和长度起决定作用；回答短时，TTFT 起决定作用。
-   在思考（reasoning）模型上，第一个可见 token 出现在思考之后，所以要把首个内容 token 时间和首 token 时间分开测量。
-   长提示词会提高 TTFT，因为模型要先读完整个提示词；缓存前缀通常有帮助。
-   按 约每秒 100 个 token 的速度，生成时间随回答长度同比例增长：输出 token 多 10 倍，流式输出的时间也约长 10 倍。
-   报告 p50 和 p95 时要注明提示词长度；不说明提示词大小的平均值没有可比性。

**本页内容**

1.  TTFT、每秒 token 数和端到端延迟分别是什么？
2.  为什么思考模型还需要第四个数字？
3.  怎样在客户端测量延迟？
4.  什么才能真正改善每个数字？
5.  提示词长度怎样改变这种取舍？
6.  BroadNet Inference 适合什么场景

“API 很慢”可能指三件不同的事，每件事的解决办法都不一样。聊天用户在等第一个字；智能体在等整个工具调用完成；批处理任务关心的是每小时处理多少 token。本文给出这三个数字的定义，演示怎样在自己的代码里测量它们，并说明每种优化实际改善的是哪个数字。

## TTFT、每秒 token 数和端到端延迟分别是什么？

NVIDIA 的基准测试指南给出了清晰的定义，而且和你在客户端能观察到的一致：

| 指标 | 衡量什么 | 谁能感受到 | 受什么影响 |
| --- | --- | --- | --- |
| [首 token 延迟](https://broadrouter.com/zh/glossary/time-to-first-token/)（TTFT） | 从发出请求到收到第一个 token | 聊天用户 | 网络、排队、提示词长度（prefill）、缓存命中 |
| token 间延迟（ITL） | token 之间的平均间隔 | 阅读流式回答的人 | 模型大小、硬件、服务器负载 |
| 单用户[每秒 token 数](https://broadrouter.com/zh/glossary/tokens-per-second/) | 首个 token 之后的输出 token 数 ÷ 生成时间（从首个 token 到最后一个 token）；等于 1 ÷ 平均 ITL | 阅读者、智能体 | 与 ITL 相同 |
| 端到端延迟 | 从发出请求到收到最后一个 token | 智能体、API、批处理 | TTFT + 生成时间 |

把它们联系起来的公式：

**端到端 ≈ TTFT +（输出 token 数 − 1）× ITL ≈ TTFT + 输出 token 数 ÷ 单用户每秒 token 数**

单用户速度和服务器[吞吐量](https://broadrouter.com/zh/glossary/throughput/)（服务器为所有用户生成的 token 总量）不是一回事；服务商可以提高其中一个，而另一个下降。

以 BroadNet 为其套餐模型公布的典型速度 约每秒 100 个 token 为例。生成时间随回答长度增长：一个 4,000 token 的代码文件，生成时间约为 50 token 分类结果的 80 倍，而两者等待的 TTFT 相同。回答短时，等待的大部分是 TTFT；回答长时，起决定作用的是速度和长度。

## 为什么思考模型还需要第四个数字？

[DeepSeek V4.1 Flash](https://broadrouter.com/zh/models/deepseek-v4.1-flash/) 这样的思考（reasoning）模型会先思考再回答，而思考也是输出 token。如果模型以 约每秒 100 个 token 的速度花 800 个 token 思考，即使网络上的 TTFT 看起来很快，用户也要等这 800 个 token 全部生成后才能看到第一个可见的字。所以要单独测量**首个内容 token 时间**。在 BroadNet Inference 上，`reasoning_effort: "low"` 可以缩短简单步骤的思考；[思考指南](https://broadrouter.com/zh/guides/reasoning-tokens-empty-response/)解释了其中的取舍。

## 怎样在客户端测量延迟？

在用户所在的位置计时，并开启[流式输出](https://broadrouter.com/zh/glossary/streaming/)。服务端计时会漏掉网络和中间的代理。

```python
import os, time, statistics
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))
```

公平的基准测试有五条规则：

1.  **固定提示词长度**并注明。500 个提示词 token 和 200,000 个提示词 token 下的 TTFT 是两个不同的数字。[token 计数器](https://broadrouter.com/tools/token-counter/)可以在发送前告诉你测试提示词有多长。
2.  用 `max_tokens` 和能写满它的提示词**固定输出长度**，这样每秒 token 数才有可比性。
3.  **报告 p50 和 p95**，而不是平均值。用户记住的是长尾延迟。
4.  **把测试分散到不同时间。** 负载在一天中会变化。
5.  **先预热。** 第一次调用要承担 DNS、TLS 和建立连接的开销；复用同一个客户端。

## 什么才能真正改善每个数字？

| 要改善 | 做法 | 原因 |
| --- | --- | --- |
| TTFT | 缩短或缓存提示词前缀 | prefill 时间随提示词长度增长；缓存的前缀可以省掉这部分计算 |
| TTFT | 保持连接预热，使用就近的区域 | 省掉建立连接和往返的时间 |
| 首个内容 token 时间 | 降低思考强度，或在简单步骤上使用非思考模型 | 回答之前的隐藏思考更少 |
| 每秒 token 数 | 在该步骤使用更小或更快的模型 | 解码速度取决于模型大小和部署方式 |
| 端到端 | 要求更短的输出（schema、字数限制） | 输出长度会成倍放大 ITL |
| 多次调用的端到端 | 在[并发](https://broadrouter.com/zh/glossary/concurrency/)限制内并行运行相互独立的调用 | 每次调用不变，但总的墙钟时间下降 |
| 感知延迟 | 向用户流式输出 | 模型边写，用户边读 |

输出长度是最被低估的手段。要求“输出包含这四个字段的 JSON”，而不是“解释你的回答”，无需改动任何基础设施，就能把生成时间缩短一个数量级。[结构化输出](https://broadrouter.com/zh/glossary/structured-output/)在这里很有用。

缓存这个手段见[为缓存设计提示词结构](https://broadrouter.com/zh/blog/prompt-structure-for-caching/)。并行这个手段很快就会撞上速率限制；参见[处理 429 错误](https://broadrouter.com/zh/blog/handle-llm-api-429-rate-limits/)。

## 提示词长度怎样改变这种取舍？

TTFT 随提示词增长，因为模型必须先处理完每个输入 token 才能开始写。这是超长提示词的隐性成本，也是[长上下文还是 RAG](https://broadrouter.com/zh/blog/long-context-vs-rag/) 这一决策的考量之一：100 万 token 的提示词能回答 RAG 回答不了的问题，但开始得更慢。如果交互速度很重要，就让主路径保持简短，只在问题需要时才发送大段上下文。

## BroadNet Inference 适合什么场景

BroadNet 为其套餐模型公布的典型速度是 约每秒 100 个 token，流式输出使用标准 SSE 格式，所以上面的代码无需修改即可运行。它没有公布 TTFT 数字或延迟 SLA，所以在决定之前，请用你自己的提示词测量；一个 $1 的 [Meteor 小时](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-latency-ttft-throughput&utm_content=body)足够跑 50 次的基准测试，初始额度也足够在 Gemma 4 VL 26B 上跑一次。如果你需要在大规模下保证亚秒级延迟，请仔细测试：按量付费密钥允许同时 4 个请求，更适合应用和智能体，而不是大流量的实时服务。模型及其价格见[模型](https://broadrouter.com/zh/models/)和[价格](https://broadrouter.com/zh/pricing/)页面。

相关免费工具（英文）

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[免费工具（英文）](https://broadrouter.com/tools/)

## 本文涉及的术语

[Token（词元）](https://broadrouter.com/zh/glossary/token/)

token（词元）是大语言模型读写文本的基本单位：由模型的分词器切分出的一个词、词的一部分、一个标点或一段字节序列。大模型 API 按 token 计数、设定限制，通常也按 token 计费。

[首 token 延迟（TTFT，time to first token）](https://broadrouter.com/zh/glossary/time-to-first-token/)

首 token 延迟（TTFT）是从向语言模型发出请求到第一个输出 token 到达的时间。它包括网络时间、服务器上的排队时间和预填充（模型读取整个提示词的步骤），所以会随提示词长度和负载增加。

[输入 token 与输出 token](https://broadrouter.com/zh/glossary/input-and-output-tokens/)

输入 token 是语言模型在一次请求中读取的 token，包括系统提示词、对话历史、工具定义和图片。输出 token 是模型生成回复的 token，包括思考内容。大模型 API 通常分别计价，输出一般更贵。

[AI 智能体（AI agent）](https://broadrouter.com/zh/glossary/agent/)

AI 智能体是由语言模型自主决定步骤、朝目标推进的系统：它决定调用哪些工具、读取结果，然后重复，直到给出最终回答或触及上限。在固定位置调用模型的固定脚本，通常称为工作流（workflow）。

[延迟（latency）](https://broadrouter.com/zh/glossary/latency/)

对于语言模型 API，延迟是一个请求从发出到收到最后一个输出 token 所用的时间。它等于首 token 延迟加上生成时间，通常以 p50、p95 等百分位而不是平均值来报告。

[并发（concurrency）](https://broadrouter.com/zh/glossary/concurrency/)

并发（concurrency）是客户端在同一时刻正在进行中的请求数。大模型 API 往往按密钥或套餐单独限制并发，与每分钟请求数分开计算，因为每个未完成的请求在响应结束前都会占用 GPU 资源。

[流式输出（streaming）](https://broadrouter.com/zh/glossary/streaming/)

流式输出是一种在语言模型仍在生成时，就把回复分成小块陆续返回的方式，而不是在最后一次性返回。当请求把 stream 设为 true 时，OpenAI 兼容 API 会通过服务器发送事件（SSE）进行流式输出。

[速率限制（rate limit）](https://broadrouter.com/zh/glossary/rate-limit/)

速率限制是 API 对客户端在一个时间窗口内的使用量设定的上限，例如每分钟请求数或每分钟 token 数。超出限制的请求会被拒绝，通常返回 HTTP 429 Too Many Requests，直到用量回落到限制以下。

## 常见问题

### 大模型 API 的首 token 延迟多少算好？

对聊天来说，短提示词下大约 1 秒以内就会让人觉得响应及时。长提示词和思考模型本身就需要更长时间。只在相同提示词长度和相同模型下比较 TTFT。

### 每秒 token 数和吞吐量是一回事吗？

不完全是。单用户每秒 token 数是一个回答流式输出的速度。吞吐量是服务器为所有用户生成的 token 总量。服务商可以提高总吞吐量，同时每个用户的速度却在下降。

### 为什么思考模型的 TTFT 这么高？

模型在可见回答之前会先生成隐藏的思考 token。第一个 token 可能很快就到，但第一个内容 token 要等思考结束。简单任务可以调低 reasoning\_effort。

### 流式输出能降低延迟吗？

它不会缩短端到端耗时。但它让用户在回答生成的同时就能阅读，所以感知延迟会降到大约等于 TTFT。

### 做可靠的延迟测试，需要多少个请求？

要足够看清长尾。每种提示词长度跑 50 到 100 个请求，就能得到可用的 p95。把它们分散到一天中的不同时段，因为负载会变化。

## 继续阅读

-   [大模型流式输出详解：SSE 分块、delta、用量与取消](https://broadrouter.com/zh/blog/llm-streaming-sse-explained/)
-   [如何组织提示词，让前缀被缓存](https://broadrouter.com/zh/blog/prompt-structure-for-caching/)
-   [长上下文还是 RAG：百万 token 什么时候能取代向量数据库](https://broadrouter.com/zh/blog/long-context-vs-rag/)
-   [BroadNet 的 GPU 硬件与推理部署方式（据 BroadNet 自述）](https://broadrouter.com/zh/blog/broadnet-gpu-fleet-and-serving/)
-   [缓存大模型 API 响应以降低成本：用 Python 实现精确匹配缓存](https://broadrouter.com/zh/blog/cache-llm-responses-cut-cost/)
-   [指南：对话补全的流式输出，以及连接中断的处理](https://broadrouter.com/zh/guides/streaming-chat-completions/)
-   [指南：推理模型为什么返回空回答](https://broadrouter.com/zh/guides/reasoning-tokens-empty-response/)

用你的真实业务负载试一试。新账户可获得 US$5 初始额度，用于 Gemma和转写。DeepSeek、GLM和Qwen3.8 需要先充值。

[开始使用](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-latency-ttft-throughput&utm_content=page-cta) ·

**来源**

-   [NVIDIA NIM 基准测试指南：大模型延迟与吞吐量指标（2026-11-14 获取）](https://docs.nvidia.com/nim/benchmarking/llm/metrics)
-   [BroadNet Inference 套餐：典型速度（2026-11-15 核实）（英文）](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [BroadNet Inference API 参考：流式输出与思考（2026-11-15 核实）（英文）](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Baseten Inference Engineering：测量延迟与吞吐量（2026-11-16 查阅）](https://www.baseten.co/inference-engineering/book/01-prerequisites/measuring-latency-and-throughput/)
