1.1 vLLM：内存管理优先

vLLM的核心问题是 “如何让模型在GPU上跑得更快、更省内存” 。它的设计出发点非常朴素：大模型推理的最大瓶颈是显存——KV Cache占用了大量显存，而传统内存管理方式造成了严重浪费。

vLLM的答案是：把操作系统管理物理内存的那套方法搬过来。通过PagedAttention将KV Cache分页存储，让显存利用率从60%提升到85%以上。这是一种自下而上的优化思路——先把底层的资源管理做到极致，上层的事情自然就好办了。

1.2 SGLang：程序执行优先

SGLang的核心问题是 “如何让复杂的LLM应用写得更爽、跑得更快” 。它不满足于仅仅做个“加速器”，而是要把LLM推理变成可编程的程序执行。

SGLang的答案是：把编译器、数据库和操作系统的思想融合在一起。通过RadixAttention实现token级别的计算复用，通过前端DSL让开发者用程序化的方式表达复杂工作流。这是一种自上而下的优化思路——先定义好“程序”这个抽象，再为这个抽象设计最高效的执行引擎。

1.3 一句话概括

2.1 KV Cache管理：分页 vs 基数树

vLLM的PagedAttention将KV Cache划分为固定大小的块（如16个token），通过块表（Block Table）将逻辑块映射到物理显存中非连续的块。这种设计的核心优势是消除内存碎片——无论请求多长、何时结束，物理内存都可以被充分利用。

SGLang的RadixAttention则用基数树（Radix Tree）来管理KV Cache。树中的每个节点存储一段连续token序列的KV Cache，新请求到达时通过最长前缀匹配找到可复用的部分。这种设计的核心优势是token级别的精确复用——共享前缀哪怕只有1个token也能被识别和复用。

关键差异：vLLM解决的是“内存怎么放得下”的问题，SGLang解决的是“怎么少算一点”的问题。前者关注空间利用率，后者关注时间复用率。

2.2 批处理策略：持续批处理 vs 动态优先级调度

vLLM的连续批处理（Continuous Batching） 在每个解码迭代步都重新评估所有请求的状态，动态决定本轮处理哪些请求。当一个请求完成时，其槽位立即被新请求填充。这种设计让GPU计算单元始终保持满载。

SGLang的零开销批调度器更进一步——让CPU调度与GPU计算在时间上重叠（overlap）。在当前批次在GPU上执行时，CPU同时为下一个批次完成调度决策，GPU无需任何等待即可无缝衔接下一个批次。

关键差异：vLLM让GPU“不停地干活”，SGLang让GPU“连等都不用等”——两者的优化层次不同。

2.3 结构化输出：后处理 vs 约束解码

vLLM对结构化输出的支持相对基础——生成文本后再用后处理进行校验和修正。这种方式实现简单，但效率不高，且可能因为格式错误需要重新生成。

SGLang则将约束解码（Constrained Decoding） 集成到调度层。用户通过JSON Schema或正则表达式定义输出格式，系统将其编译成压缩有限状态机（FSM） ，在每一步解码时只允许符合约束的token被生成。配合跳跃前向优化（Jump-Forward） ，可以跳过60%-75%的固定结构字符的decode步骤。

关键差异：vLLM是“先生成再纠错”，SGLang是“从一开始就不允许出错”——前者是后处理，后者是编译时约束。

3.1 吞吐量

在H200集群部署DeepSeek 671B满血版的实测中：

另一项独立基准测试显示，SGLang（16,215 tok/s）和LMDeploy（16,132 tok/s）相比优化充分的vLLM（12,553 tok/s）保持了约29%的优势。

3.2 延迟与显存

SGLang的首次请求延迟更低（85-120ms vs 150-200ms），但vLLM的显存利用率更高（91% vs 82%）——这反映了两种设计的不同取舍：SGLang用一部分显存换取计算复用带来的延迟优势，vLLM则把每一寸显存都用到极致。

4.1 选vLLM的场景

• 通用在线推理服务：需要稳定、高吞吐的通用推理能力，vLLM是成熟可靠的选择
• 长文本生成：文档写作、代码生成等需要处理超长上下文的场景
• 分布式集群部署：需要扩展到多节点、多卡的大规模部署
• 多模型并发：需要同时服务多个不同模型
• 生产环境稳定性优先：vLLM已加入PyTorch基金会，社区成熟，文档完善

4.2 选SGLang的场景

• 复杂Agent工作流：多轮推理、工具调用、条件分支的智能体应用
• RAG与多轮对话：大量请求共享相同的检索文档或对话历史前缀
• 结构化输出要求严格：金融、医疗等领域需要JSON/正则约束输出
• 资源受限环境：单卡部署、边缘设备
• 追求极致吞吐量：在相同硬件上追求最高吞吐量的场景

4.3 选型决策树

1
你的场景是什么？
2
├─ 简单的一问一答、通用推理 → vLLM
3
├─ 长文本生成（>2048 tokens）→ vLLM
4
├─ 分布式多卡/多节点部署 → vLLM
5
├─ 复杂的Agent、多轮对话 → SGLang
6
├─ 严格的JSON/结构化输出 → SGLang
7
├─ RAG、few-shot learning（大量共享前缀）→ SGLang
8
└─ 资源受限、单卡部署 → SGLang

5.1 vLLM 快速上手

环境要求：Python 3.8+，CUDA 11.8或12.1，NVIDIA GPU

Step 1：安装

1
# 创建虚拟环境（推荐）
2
conda create -n vllm_env python=3.10
3
conda activate vllm_env
4

5
# 安装vLLM
6
pip install vllm

官方提供预编译wheel包，支持CUDA 11.8和12.1。如需最新功能，可安装nightly版本。

Step 2：离线批量推理

1
from vllm import LLM, SamplingParams
2

3
# 加载模型
4
llm = LLM(model="meta-llama/Llama-3.1-8B-Instruct")
5

6
# 设置采样参数
7
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=100)
8

9
# 执行推理
10
outputs = llm.generate(["What is AI?", "Explain quantum computing"], sampling_params)
11

12
for output in outputs:
13
    print(f"Prompt: {output.prompt}")
14
    print(f"Generated: {output.outputs[0].text}\n")

Step 3：启动API服务

1
python -m vllm.entrypoints.openai.api_server \
2
    --model meta-llama/Llama-3.1-8B-Instruct \
3
    --tensor-parallel-size 2 \
4
    --port 8000

启动后即可通过OpenAI兼容的API访问：

1
import openai
2
client = openai.OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
3
response = client.completions.create(model="meta-llama/Llama-3.1-8B-Instruct", prompt="Hello")

5.2 SGLang 快速上手

环境要求：Python 3.8+，CUDA 11.8+，NVIDIA GPU

Step 1：安装

1
# 创建虚拟环境
2
conda create -n sglang_env python=3.10
3
conda activate sglang_env
4

5
# 安装SGLang（推荐安装all extras）
6
pip install "sglang[all]"
7

8
# 安装FlashInfer CUDA内核（推荐）
9
pip install flashinfer -i https://flashinfer.ai/whl/cu121/torch2.4/

从源码安装：

1
git clone -b v0.2.14 https://github.com/sgl-project/sglang.git
2
cd sglang
3
pip install -e "python[all]"

使用Docker：

1
docker run --gpus all -p 30000:30000 lmsysorg/sglang:latest \
2
    python -m sglang.launch_server --model-path meta-llama/Llama-3.1-8B-Instruct

Step 2：启动服务

1
python -m sglang.launch_server \
2
    --model-path meta-llama/Llama-3.1-8B-Instruct \
3
    --port 30000

Step 3：使用前端DSL编程

1
import sglang as sgl
2

3
@sgl.function
4
def multi_turn_chat(s, user_question, history):
5
    s += "System: You are a helpful assistant.\n"
6
    for turn in history:
7
        s += f"User: {turn['user']}\n"
8
        s += f"Assistant: {turn['assistant']}\n"
9
    s += f"User: {user_question}\n"
10
    s += sgl.gen("response", max_tokens=256)
11

12
# 执行
13
state = multi_turn_chat.run(
14
    user_question="What is the capital of France?",
15
    history=[{"user": "Hello", "assistant": "Hi there!"}]
16
)
17
print(state["response"])

Step 4：结构化输出（JSON约束）

1
@sgl.function
2
def json_output(s, topic):
3
    s += f"Generate a JSON about {topic}:\n"
4
    s += sgl.gen(
5
        "json_output",
6
        max_tokens=256,
7
        temperature=0.1,
8
        regex=r'\{[^{}]*\}'  # 约束为JSON格式
9
    )