101.7在线收听速查手册：告别环境配置卡壳
配置环境就卡半天，这种绝望感谁懂？装个依赖报错，改个端口冲突，折腾两小时连个“Hello World”都没跑通。这时候你急需的，不是一篇长篇大论的理论，而是一份能直接抄作业的速查手册。
很多人把“101.7在线收听”当成一个神秘的黑话，其实它指的是基于 RFC 规范 标准实现的轻量级音频流媒体传输协议，常用于低延迟直播或即时通讯场景。但在实际工程落地中，90% 的人死在“环境搭建”和“参数配置”这两个坎上。
今天这篇实战教程，我们就从零开始，用 Python 搭建一个最小可行的“101.7在线收听”服务端与客户端。不聊虚的，只讲怎么让代码跑起来，怎么避坑，怎么把延迟压到毫秒级。
项目目标与核心难点
我们要实现的不是一个花里胡哨的 App，而是一个最小可行产品（MVP）。
核心目标：
服务端能接收并转发音频流。
客户端能实时发送本地麦克风音频。
另一台客户端能实时“收听”到前者的声音，延迟控制在 200ms 以内。
为什么难？
协议非标准 HTTP： 它不是简单的文件下载，而是基于 UDP 或 TCP 的实时流传输，涉及分包、重传（或丢弃）、抖动缓冲。
环境依赖地狱： 涉及音频采集（PyAudio/PortAudio）、网络通信（Websocket/UDP）、并发处理。
RFC 规范落地细节： 虽然底层参考了 RFC 5618 等关于实时传输协议的规范，但具体到应用层封装，各家实现千差万别，网上教程大多停留在理论层面，缺乏可运行的代码骨架。
我们的策略是：化繁为简。先跑通 TCP + WebSocket 方案，保证稳定性，再考虑 UDP 优化。
目录结构设计
一个清晰的项目结构是避免混乱的关键。我们采用标准的 Python 工程化结构：
project-101.7-listener/
├── requirements.txt # 依赖列表
├── main_server.py # 服务端入口
├── main_client.py # 客户端入口
├── core/
│ ├── __init__.py
│ ├── audio_processor.py # 音频采集与编码
│ └── network_manager.py # 网络连接与消息处理
├── utils/
│ ├── __init__.py
│ └── logger.py # 日志工具
└── README.md
关键文件说明：
audio_processor.py：负责调用系统音频库，获取 PCM 数据，并进行简单的分帧处理。
network_manager.py：负责维护 WebSocket 连接，处理消息的收发与路由。
main_server.py / main_client.py：分别启动服务端监听和客户端连接逻辑。
核心代码实现
1. 依赖安装
环境配置是第一步，也是最容易卡住的一步。确保你的 Python 版本在 3.8+。
pip install websockets pyaudio numpy
避坑提示：
如果在 Windows 上安装 pyaudio 报错，大概率是因为缺少 C++ 编译器或 PortAudio 库。
对策 A（推荐）： 使用预编译轮子 pip install pyaudio -f https://www.lfd.uci.edu/~gohlke/pythonlibs/。
对策 B： 安装 Visual C++ Build Tools 和 PortAudio 开发包。
2. 音频处理模块 (core/audio_processor.py)
这里我们使用 pyaudio 采集麦克风数据。为了传输效率，我们直接发送原始的 PCM 字节流，暂不做复杂的 MP3/AAC 编码，以减少 CPU 占用和编码延迟。
import pyaudio
import numpy as np
class AudioProcessor:
def __init__(self, sample_rate=16000, channels=1, chunk_size=4096):
self.sample_rate = sample_rate
self.channels = channels
self.chunk_size = chunk_size
self.pa = pyaudio.PyAudio()
self.stream = None
def start(self):
初始化音频流
try:
self.stream = self.pa.open(
format=pyaudio.paInt16,
channels=self.channels,
rate=self.sample_rate,
input=True,
frames_per_buffer=self.chunk_size
)
except OSError as e:
print(f音频设备初始化失败: {e})
raise
def read_audio(self):
读取一块音频数据
返回: bytes 格式的 PCM 数据
if not self.stream:
return b
data = self.stream.read(self.chunk_size, exception_on_overflow=False)
# 这里可以加入简单的降噪或音量归一化，但为了低延迟，先保持原样
return data
def stop(self):
停止音频流并释放资源
if self.stream:
self.stream.stop_stream()
self.stream.close()
self.pa.terminate()
逐行讲解：
paInt16：使用 16 位整型，这是语音通信的标准精度，平衡了音质与带宽。
exception_on_overflow=False：在高速采集时，如果处理不及时，音频缓冲区会溢出。设为 False 可以丢弃旧数据，保证实时性，符合流媒体“实时优先”的原则。
3. 网络管理与服务端 (main_server.py)
服务端充当“中继站”。它不需要关心音频内容，只负责把 A 发来的数据转发给 B。
import asyncio
import websockets
import json
# 全局连接池，key为client_id, value为websocket连接
clients = {}
async def handler(websocket, path):
处理新的 WebSocket 连接
client_id = str(id(websocket)) # 简单用对象ID作为唯一标识，生产环境请用UUID
print(fClient {client_id} connected)
# 加入连接池
clients[client_id] = websocket
try:
async for message in websocket:
# 假设消息格式: {type: audio, data: base64_encoded_bytes}
# 为了简化演示，我们直接透传二进制数据
# 但在实际中，建议加上头部标识谁在说话
broadcast_data(message, exclude_id=client_id)
except websockets.exceptions.ConnectionClosed:
pass
finally:
# 断开连接时从池中移除
if client_id in clients:
del clients[client_id]
print(fClient {client_id} disconnected)
def broadcast_data(data, exclude_id=None):
向所有其他客户端广播数据
for cid, ws in clients.items():
if cid != exclude_id:
# asyncio.ensure_future 用于非阻塞发送
asyncio.ensure_future(ws.send(data))
async def main():
# 启动 WebSocket 服务器
async with websockets.serve(handler, 0.0.0.0, 8765):
print(Server started on ws://0.0.0.0:8765)
await asyncio.Future() # 运行 forever
if __name__ == __main__:
asyncio.run(main())
关键点：
非阻塞 IO： websockets 库基于 asyncio，单线程即可处理成千上万连接，这是高并发的基础。
数据透传： 服务端不解析音频内容，只做路由，极大降低了服务端 CPU 负担。
4. 客户端实现 (main_client.py)
客户端需要同时做两件事：
收： 监听服务器发来的音频数据，并播放。
发： 采集本地麦克风音频，发送给服务器。
这两个任务必须在不同的协程或线程中运行，否则会互相阻塞。
import asyncio
import websockets
import pyaudio
import base64
import numpy as np
class Client:
def __init__(self):
self.ws = None
self.is_running = False
self.pa = pyaudio.PyAudio()
self.input_stream = None
self.output_stream = None
async def connect(self):
建立 WebSocket 连接
self.ws = await websockets.connect(ws://localhost:8765)
print(Connected to server)
self.is_running = True
async def receive_audio(self):
接收并播放音频
try:
async for message in self.ws:
if self.is_running and self.output_stream:
# 假设收到的是原始 PCM bytes
# 注意：接收到的数据可能因为网络抖动有大小不一，这里假设服务端发送的是固定块
self.output_stream.write(message)
except websockets.exceptions.ConnectionClosed:
print(Connection closed)
self.is_running = False
async def send_audio(self):
采集并发送音频
# 初始化输入流
self.input_stream = self.pa.open(
format=pyaudio.paInt16,
channels=1,
rate=16000,
input=True,
frames_per_buffer=4096
)
while self.is_running:
data = self.input_stream.read(4096, exception_on_overflow=False)
if data:
try:
# 发送二进制数据
await self.ws.send(data)
except Exception as e:
print(fSend error: {e})
break
# 稍微 sleep 一下，避免 CPU 空转，虽然 asyncio 会自动调度，但显式控制更稳妥
await asyncio.sleep(0.01)
def start_output(self):
初始化输出流
self.output_stream = self.pa.open(
format=pyaudio.paInt16,
channels=1,
rate=16000,
output=True
)
def stop(self):
清理资源
self.is_running = False
if self.input_stream:
self.input_stream.stop_stream()
self.input_stream.close()
if self.output_stream:
self.output_stream.stop_stream()
self.output_stream.close()
self.pa.terminate()
async def main():
client = Client()
try:
await client.connect()
client.start_output()
# 并发运行发送和接收任务
await asyncio.gather(
client.receive_audio(),
client.send_audio()
)
except KeyboardInterrupt:
pass
finally:
client.stop()
print(Client stopped)
if __name__ == __main__:
asyncio.run(main())
逐行讲解与避坑：
asyncio.gather：这是 Python 异步编程的核心。它将 receive_audio 和 send_audio 两个协程并发执行。如果写成顺序执行，程序会卡死在 receive 上，因为 receive 是阻塞等待消息的。
播放卡顿问题： 如果在播放时出现爆音或卡顿，通常是因为 output_stream.write 是阻塞的。如果网络数据到达速度不均，或者本地 CPU 负载高，缓冲区会溢出。
对策： 引入一个 queue.Queue 作为缓冲池。接收协程将数据放入队列，独立的播放线程从队列取数据写入 output_stream。这能解耦网络波动对播放的影响。
运行与测试
1. 启动服务
打开三个终端窗口。
终端 1：启动服务端
python main_server.py
看到 Server started on ws://0.0.0.0:8765 即成功。
终端 2：启动客户端 A（说话者）
python main_client.py
终端 3：启动客户端 B（听者）
python main_client.py
2. 测试流程
在终端 2 中对着麦克风说话。
在终端 3 中，你应该能实时听到终端 2 的声音。
在终端 3 中说话，终端 2 应该能听到。
常见问题排查：
听不到声音：
检查终端 3 是否成功连接（看日志）。
检查系统默认音频输出设备是否正确。
检查 pyaudio 是否采集到了数据（可以在 send_audio 中打印 len(data)，确认不为 0）。
回声（Echo）：
如果你用同一台电脑的扬声器输出，麦克风又采集到了扬声器发出的声音，就会形成回声。
对策： 在测试时，请戴上耳机。生产环境中，这需要 AEC（回声消除）算法，那是音频处理的深水区，这里暂不展开。
优化扩展
目前的实现是“能跑”，但离“好用”还有距离。以下是几个进阶方向：
1. 引入抖动缓冲区 (Jitter Buffer)
网络传输是突发的，而音频播放是连续的。如果直接把收到的包立刻播放，网络稍有波动就会卡顿。
方案： 客户端维护一个环形缓冲区（Ring Buffer），存储最近 N 毫秒的音频数据。播放时，从缓冲区头部读取。如果缓冲区空了，才拉取新数据。这样能平滑网络抖动。
2. 协议升级：从 TCP 到 UDP
websockets 底层是 TCP，TCP 保证不丢包，但会排队。对于实时音频，丢 1 个包没关系，但如果因为重传导致延迟增加 100ms，那就致命了。
方案： 改用 UDP 传输。可以参考 RFC 3550 (RTP) 规范，自己封装一个简单的 RTP 头，包含序列号、时间戳。接收端根据时间戳排序，丢弃超时包，只播放最新数据。
3. 音频编码压缩
发送原始 PCM 数据，带宽占用大（16kHz * 16bit * 1ch ≈ 32kbps）。
方案： 使用 Opus 编码。Opus 是专为实时语音设计的编码格式，在低延迟下音质极佳，且压缩率极高。
库推荐： pyogg 或 opuslib。
4. 安全与鉴权
目前任何人都能连接服务器。
方案： 在 WebSocket 握手阶段加入 Token 验证。客户端启动时先通过 HTTP 接口获取 Token，然后在连接 URL 中带上 ?token=xxx。服务端校验 Token 有效性后才允许连接。
小结
我们从一个空白的环境开始，一步步搭建了“101.7在线收听”的最小可行原型。
环境配置：解决了 pyaudio 的安装难题，这是入门的第一道门槛。
架构设计：采用了异步非阻塞模型，确保高并发下的低延迟。
核心逻辑：实现了音频采集、网络透传、实时播放的完整闭环。
避坑指南：指出了回声、缓冲区溢出、TCP 排队等常见问题及初步对策。
这篇速查手册的价值不在于代码有多复杂，而在于它提供了一个可运行的骨架。你可以在此基础上，加入 Opus 编码、Jitter Buffer、RTP 协议，逐步演进成一个生产级的实时通信模块。
技术没有终点，只有不断的迭代。
你在项目里踩过这个坑吗？比如音频延迟忽高忽低，或者多人同时在线时服务器 CPU 飙升？评论区聊聊，我们一起拆解问题。 
长河君 · 2026/9/22 14:14:50 · 阅读 1.2k 101.7在线收听速查手册：告别环境配置卡壳
101.7在线收听速查手册：告别环境配置卡壳
配置环境就卡半天，这种绝望感谁懂？装个依赖报错，改个端口冲突，折腾两小时连个“Hello World”都没跑通。这时候你急需的，不是一篇长篇大论的理论，而是一份能直接抄作业的速查手册。
很多人把“101.7在线收听”当成一个神秘的黑话，其实它指的是基于 RFC 规范 标准实现的轻量级音频流媒体传输协议，常用于低延迟直播或即时通讯场景。但在实际工程落地中，90% 的人死在“环境搭建”和“参数配置”这两个坎上。
今天这篇实战教程，我们就从零开始，用 Python 搭建一个最小可行的“101.7在线收听”服务端与客户端。不聊虚的，只讲怎么让代码跑起来，怎么避坑，怎么把延迟压到毫秒级。
项目目标与核心难点
我们要实现的不是一个花里胡哨的 App，而是一个最小可行产品（MVP）。
核心目标：
服务端能接收并转发音频流。
客户端能实时发送本地麦克风音频。
另一台客户端能实时“收听”到前者的声音，延迟控制在 200ms 以内。
为什么难？
协议非标准 HTTP： 它不是简单的文件下载，而是基于 UDP 或 TCP 的实时流传输，涉及分包、重传（或丢弃）、抖动缓冲。
环境依赖地狱： 涉及音频采集（PyAudio/PortAudio）、网络通信（Websocket/UDP）、并发处理。
RFC 规范落地细节： 虽然底层参考了 RFC 5618 等关于实时传输协议的规范，但具体到应用层封装，各家实现千差万别，网上教程大多停留在理论层面，缺乏可运行的代码骨架。
我们的策略是：化繁为简。先跑通 TCP + WebSocket 方案，保证稳定性，再考虑 UDP 优化。
目录结构设计
一个清晰的项目结构是避免混乱的关键。我们采用标准的 Python 工程化结构：
project-101.7-listener/
├── requirements.txt # 依赖列表
├── main_server.py # 服务端入口
├── main_client.py # 客户端入口
├── core/
│ ├── __init__.py
│ ├── audio_processor.py # 音频采集与编码
│ └── network_manager.py # 网络连接与消息处理
├── utils/
│ ├── __init__.py
│ └── logger.py # 日志工具
└── README.md
关键文件说明：
audio_processor.py：负责调用系统音频库，获取 PCM 数据，并进行简单的分帧处理。
network_manager.py：负责维护 WebSocket 连接，处理消息的收发与路由。
main_server.py / main_client.py：分别启动服务端监听和客户端连接逻辑。
核心代码实现
1. 依赖安装
环境配置是第一步，也是最容易卡住的一步。确保你的 Python 版本在 3.8+。
pip install websockets pyaudio numpy
避坑提示：
如果在 Windows 上安装 pyaudio 报错，大概率是因为缺少 C++ 编译器或 PortAudio 库。
对策 A（推荐）： 使用预编译轮子 pip install pyaudio -f https://www.lfd.uci.edu/~gohlke/pythonlibs/。
对策 B： 安装 Visual C++ Build Tools 和 PortAudio 开发包。
2. 音频处理模块 (core/audio_processor.py)
这里我们使用 pyaudio 采集麦克风数据。为了传输效率，我们直接发送原始的 PCM 字节流，暂不做复杂的 MP3/AAC 编码，以减少 CPU 占用和编码延迟。
import pyaudio
import numpy as np
class AudioProcessor:
def __init__(self, sample_rate=16000, channels=1, chunk_size=4096):
self.sample_rate = sample_rate
self.channels = channels
self.chunk_size = chunk_size
self.pa = pyaudio.PyAudio()
self.stream = None
def start(self):
初始化音频流
try:
self.stream = self.pa.open(
format=pyaudio.paInt16,
channels=self.channels,
rate=self.sample_rate,
input=True,
frames_per_buffer=self.chunk_size
)
except OSError as e:
print(f音频设备初始化失败: {e})
raise
def read_audio(self):
读取一块音频数据
返回: bytes 格式的 PCM 数据
if not self.stream:
return b
data = self.stream.read(self.chunk_size, exception_on_overflow=False)
# 这里可以加入简单的降噪或音量归一化，但为了低延迟，先保持原样
return data
def stop(self):
停止音频流并释放资源
if self.stream:
self.stream.stop_stream()
self.stream.close()
self.pa.terminate()
逐行讲解：
paInt16：使用 16 位整型，这是语音通信的标准精度，平衡了音质与带宽。
exception_on_overflow=False：在高速采集时，如果处理不及时，音频缓冲区会溢出。设为 False 可以丢弃旧数据，保证实时性，符合流媒体“实时优先”的原则。
3. 网络管理与服务端 (main_server.py)
服务端充当“中继站”。它不需要关心音频内容，只负责把 A 发来的数据转发给 B。
import asyncio
import websockets
import json
# 全局连接池，key为client_id, value为websocket连接
clients = {}
async def handler(websocket, path):
处理新的 WebSocket 连接
client_id = str(id(websocket)) # 简单用对象ID作为唯一标识，生产环境请用UUID
print(fClient {client_id} connected)
# 加入连接池
clients[client_id] = websocket
try:
async for message in websocket:
# 假设消息格式: {type: audio, data: base64_encoded_bytes}
# 为了简化演示，我们直接透传二进制数据
# 但在实际中，建议加上头部标识谁在说话
broadcast_data(message, exclude_id=client_id)
except websockets.exceptions.ConnectionClosed:
pass
finally:
# 断开连接时从池中移除
if client_id in clients:
del clients[client_id]
print(fClient {client_id} disconnected)
def broadcast_data(data, exclude_id=None):
向所有其他客户端广播数据
for cid, ws in clients.items():
if cid != exclude_id:
# asyncio.ensure_future 用于非阻塞发送
asyncio.ensure_future(ws.send(data))
async def main():
# 启动 WebSocket 服务器
async with websockets.serve(handler, 0.0.0.0, 8765):
print(Server started on ws://0.0.0.0:8765)
await asyncio.Future() # 运行 forever
if __name__ == __main__:
asyncio.run(main())
关键点：
非阻塞 IO： websockets 库基于 asyncio，单线程即可处理成千上万连接，这是高并发的基础。
数据透传： 服务端不解析音频内容，只做路由，极大降低了服务端 CPU 负担。
4. 客户端实现 (main_client.py)
客户端需要同时做两件事：
收： 监听服务器发来的音频数据，并播放。
发： 采集本地麦克风音频，发送给服务器。
这两个任务必须在不同的协程或线程中运行，否则会互相阻塞。
import asyncio
import websockets
import pyaudio
import base64
import numpy as np
class Client:
def __init__(self):
self.ws = None
self.is_running = False
self.pa = pyaudio.PyAudio()
self.input_stream = None
self.output_stream = None
async def connect(self):
建立 WebSocket 连接
self.ws = await websockets.connect(ws://localhost:8765)
print(Connected to server)
self.is_running = True
async def receive_audio(self):
接收并播放音频
try:
async for message in self.ws:
if self.is_running and self.output_stream:
# 假设收到的是原始 PCM bytes
# 注意：接收到的数据可能因为网络抖动有大小不一，这里假设服务端发送的是固定块
self.output_stream.write(message)
except websockets.exceptions.ConnectionClosed:
print(Connection closed)
self.is_running = False
async def send_audio(self):
采集并发送音频
# 初始化输入流
self.input_stream = self.pa.open(
format=pyaudio.paInt16,
channels=1,
rate=16000,
input=True,
frames_per_buffer=4096
)
while self.is_running:
data = self.input_stream.read(4096, exception_on_overflow=False)
if data:
try:
# 发送二进制数据
await self.ws.send(data)
except Exception as e:
print(fSend error: {e})
break
# 稍微 sleep 一下，避免 CPU 空转，虽然 asyncio 会自动调度，但显式控制更稳妥
await asyncio.sleep(0.01)
def start_output(self):
初始化输出流
self.output_stream = self.pa.open(
format=pyaudio.paInt16,
channels=1,
rate=16000,
output=True
)
def stop(self):
清理资源
self.is_running = False
if self.input_stream:
self.input_stream.stop_stream()
self.input_stream.close()
if self.output_stream:
self.output_stream.stop_stream()
self.output_stream.close()
self.pa.terminate()
async def main():
client = Client()
try:
await client.connect()
client.start_output()
# 并发运行发送和接收任务
await asyncio.gather(
client.receive_audio(),
client.send_audio()
)
except KeyboardInterrupt:
pass
finally:
client.stop()
print(Client stopped)
if __name__ == __main__:
asyncio.run(main())
逐行讲解与避坑：
asyncio.gather：这是 Python 异步编程的核心。它将 receive_audio 和 send_audio 两个协程并发执行。如果写成顺序执行，程序会卡死在 receive 上，因为 receive 是阻塞等待消息的。
播放卡顿问题： 如果在播放时出现爆音或卡顿，通常是因为 output_stream.write 是阻塞的。如果网络数据到达速度不均，或者本地 CPU 负载高，缓冲区会溢出。
对策： 引入一个 queue.Queue 作为缓冲池。接收协程将数据放入队列，独立的播放线程从队列取数据写入 output_stream。这能解耦网络波动对播放的影响。
运行与测试
1. 启动服务
打开三个终端窗口。
终端 1：启动服务端
python main_server.py
看到 Server started on ws://0.0.0.0:8765 即成功。
终端 2：启动客户端 A（说话者）
python main_client.py
终端 3：启动客户端 B（听者）
python main_client.py
2. 测试流程
在终端 2 中对着麦克风说话。
在终端 3 中，你应该能实时听到终端 2 的声音。
在终端 3 中说话，终端 2 应该能听到。
常见问题排查：
听不到声音：
检查终端 3 是否成功连接（看日志）。
检查系统默认音频输出设备是否正确。
检查 pyaudio 是否采集到了数据（可以在 send_audio 中打印 len(data)，确认不为 0）。
回声（Echo）：
如果你用同一台电脑的扬声器输出，麦克风又采集到了扬声器发出的声音，就会形成回声。
对策： 在测试时，请戴上耳机。生产环境中，这需要 AEC（回声消除）算法，那是音频处理的深水区，这里暂不展开。
优化扩展
目前的实现是“能跑”，但离“好用”还有距离。以下是几个进阶方向：
1. 引入抖动缓冲区 (Jitter Buffer)
网络传输是突发的，而音频播放是连续的。如果直接把收到的包立刻播放，网络稍有波动就会卡顿。
方案： 客户端维护一个环形缓冲区（Ring Buffer），存储最近 N 毫秒的音频数据。播放时，从缓冲区头部读取。如果缓冲区空了，才拉取新数据。这样能平滑网络抖动。
2. 协议升级：从 TCP 到 UDP
websockets 底层是 TCP，TCP 保证不丢包，但会排队。对于实时音频，丢 1 个包没关系，但如果因为重传导致延迟增加 100ms，那就致命了。
方案： 改用 UDP 传输。可以参考 RFC 3550 (RTP) 规范，自己封装一个简单的 RTP 头，包含序列号、时间戳。接收端根据时间戳排序，丢弃超时包，只播放最新数据。
3. 音频编码压缩
发送原始 PCM 数据，带宽占用大（16kHz * 16bit * 1ch ≈ 32kbps）。
方案： 使用 Opus 编码。Opus 是专为实时语音设计的编码格式，在低延迟下音质极佳，且压缩率极高。
库推荐： pyogg 或 opuslib。
4. 安全与鉴权
目前任何人都能连接服务器。
方案： 在 WebSocket 握手阶段加入 Token 验证。客户端启动时先通过 HTTP 接口获取 Token，然后在连接 URL 中带上 ?token=xxx。服务端校验 Token 有效性后才允许连接。
小结
我们从一个空白的环境开始，一步步搭建了“101.7在线收听”的最小可行原型。
环境配置：解决了 pyaudio 的安装难题，这是入门的第一道门槛。
架构设计：采用了异步非阻塞模型，确保高并发下的低延迟。
核心逻辑：实现了音频采集、网络透传、实时播放的完整闭环。
避坑指南：指出了回声、缓冲区溢出、TCP 排队等常见问题及初步对策。
这篇速查手册的价值不在于代码有多复杂，而在于它提供了一个可运行的骨架。你可以在此基础上，加入 Opus 编码、Jitter Buffer、RTP 协议，逐步演进成一个生产级的实时通信模块。
技术没有终点，只有不断的迭代。
你在项目里踩过这个坑吗？比如音频延迟忽高忽低，或者多人同时在线时服务器 CPU 飙升？评论区聊聊，我们一起拆解问题。