<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="zh_CN">
  <title>Adventure in DevOps</title>
  <subtitle>宅男拯救世界</subtitle>
  <link href="https://amancando.xyz/" rel="alternate" type="text/html"/>
  <link href="https://amancando.xyz/atom.xml" rel="self" type="application/atom+xml"/>
  <id>https://amancando.xyz/</id>
  <updated>2026-11-12T00:00:00.000Z</updated>
  <entry>
    <title>ping 不高，为什么还是会瞬移</title>
    <link href="https://amancando.xyz/posts/%E7%BD%91%E7%BB%9C%E5%9B%9B%E5%A4%A7%E6%97%B6%E5%BB%B6/" rel="alternate" type="text/html"/>
    <id>https://amancando.xyz/posts/%E7%BD%91%E7%BB%9C%E5%9B%9B%E5%A4%A7%E6%97%B6%E5%BB%B6/</id>
    <published>2026-11-12T00:00:00.000Z</published>
    <updated>2026-11-12T00:00:00.000Z</updated>
    <summary>把端到端时延拆成四段，看清游戏卡顿和瞬移分别卡在哪一步。</summary>
    <content type="html"><![CDATA[<h1>ping 不高，为什么还是会瞬移</h1>
<blockquote>
<p>这篇是整理「网络时延」那一节时留下的笔记。之前我也只会笼统说一句「网不好」，直到有次排位，客户端显示 32ms，人却一步一闪、技能按下去没反应。翻回教材才明白：把「延迟」当成一个数，是最容易把自己绕进去的地方。写下来给自己留个底，也顺手把初稿里几处说错的说法一起改掉。</p>
</blockquote>
<hr />
<h2>我原本把「延迟」当成一个数</h2>
<p>打游戏遇到的「延迟高」「画面卡」「人物瞬移」「技能失灵」，我以前都归到同一个词里。但它们是不同层面的现象，混在一起就没法定位。</p>
<p>教材里，端到端时延不是一个数，而是<strong>每一跳上四段时延的和</strong>：</p>
<pre><code>d(单跳) = d(处理) + d(排队) + d(发送) + d(传播)
d(端到端) = 路径上所有跳的 d(单跳) 之和
</code></pre>
<p>这里最容易漏掉的是「每一跳」——从你的电脑到游戏服务器，中间可能经过十几台路由器，每台都要把这四段走一遍。所以真正该问的不是「延迟为什么高」，而是**「这四段里，哪一段在变」**。</p>
<p>有个前提得先说清楚：这个式子描述的是<strong>单向的网络时延</strong>。客户端显示的 ping 是往返 RTT，还要算上回程；而画面卡不卡，还叠加了本地帧率、服务器 tick、客户端预测与回滚。网络时延是其中一层，不是全部。</p>
<hr />
<h2>先看一台路由器里发生了什么</h2>
<p>数据包完整到达一台路由器的输入端口后（存储转发，得先收完整个包），顺序是固定的：</p>
<p><img src="./images/01-timeline.svg" alt="一台路由器里，一个数据包经历的四段时延" /></p>
<ol>
<li>处理：读包头、校验、查转发表，决定从哪个出口走。</li>
<li>排队：出口忙，就进输出队列等着。</li>
<li>发送：轮到它了，把每个比特依次推上链路。</li>
<li>传播：比特变成光/电信号，在光纤里跑到下一台设备。</li>
</ol>
<p>顺序不会乱，也不会交叉。走完这四步才算「过了这一跳」，然后下一台设备重复一遍。</p>
<hr />
<h2>四段分别是什么，谁在决定它</h2>
<h3>处理时延：设备查表的时间</h3>
<p>包到了，路由器要先解析头部、校验完整性、查转发表、定出口，这段耗时就是处理时延。</p>
<p><strong>每一台中转设备都会产生它，不是终点专属</strong>——这是初稿里我特意纠正过的一点，原来我也以为只有服务器那头才算。</p>
<p>正常家用路由器和运营商设备上是微秒级，且比较稳定，通常不是卡顿来源。但要加个限定：如果中间夹着 NAT、防火墙、DPI、隧道封装、QoS 分类，或者是一台 CPU 软路由在跑高 PPS 小包，这段就不一定还能「近似忽略」。</p>
<h3>排队时延：等出口的时间，也是重点</h3>
<p>处理完知道该往哪走了，但出口链路可能正忙着发别的包。这时候包进<strong>输出端口的缓存队列</strong>排队，等到轮到自己被发送，这段就是排队时延。</p>
<p>出口空闲时它接近 0；一旦链路利用率上去了，它会突然变大，而且<strong>每个包等的时间都不一样</strong>。这带来两个后果：</p>
<ul>
<li><strong>抖动</strong>：相邻包的时延忽长忽短，平均值可能仍然很好看。</li>
<li><strong>丢包</strong>：队列满了（<em>tail drop</em>），后面的包直接被扔掉。</li>
</ul>
<p><img src="./images/02-queue-jitter.svg" alt="出口空闲与拥塞时，到达间隔如何变成抖动与丢包" /></p>
<p>举个能算的例子。游戏上行包通常几十字节，本身几乎不占带宽；但家里有人开满速上传，一个 1500 字节的包在 10 Mbps 上行上要发 <code>12000 bit / 10^7 bit/s = 1.2 ms</code>。队列里若排了 50 个这样的包，后来的游戏包就要多等约 60ms。带宽没变、ping 均值可能还是三十几，体验却已经碎了。</p>
<p>还有个反直觉的情况叫 <strong>bufferbloat</strong>：路由器队列做得太大，包不丢、但一直排队，延迟能稳定在几百毫秒。这时候「不丢包」反而是坏消息。</p>
<p>所以「ping 不高却瞬移」这个现象，主要不是平均延迟高，而是<strong>排队时延的波动加上 UDP 丢包</strong>。补一句：ICMP ping 常被网络设备限速或降优先级，它测的也不完全是游戏 UDP 流走的那条路，参考价值有限。</p>
<h3>发送时延：把包推上链路的时间</h3>
<p>轮到发送了，设备把包的每一个比特依次推到物理链路上，这段耗时是发送时延（也叫传输时延 transmission delay）：</p>
<pre><code>d(发送) = 数据包长度 L / 链路带宽 R
</code></pre>
<p>注意它的定义：<strong>是「推完整个包」的时间，不是「等待开始发送」的时间</strong>。等待那部分属于排队时延，这是初稿里我写反过的地方。</p>
<p>游戏包按 64 字节算，在 100 Mbps 链路上是 <code>512 bit / 10^8 bit/s ≈ 5 µs</code>，确实小到可以忽略。</p>
<h3>传播时延：比特在路上跑的时间</h3>
<p>包已经上了链路，信号从这台设备走到下一台设备的物理耗时：</p>
<pre><code>d(传播) = 链路距离 d / 传播速度 v
</code></pre>
<p>光纤里 <code>v ≈ 2×10⁸ m/s</code>（真空光速的约 2/3，受折射率影响）。1000 公里单程就是 5ms，往返 10ms；实际光缆不会走直线、还要叠加每跳转发，所以跨省三四十毫秒很正常。</p>
<p><img src="./images/03-transmission-vs-propagation.svg" alt="发送时延与传播时延：加带宽只影响前者" /></p>
<p>这两段最容易被混成一个东西，我专门画了张图。结论很朴素：<strong>加带宽只减小 <code>L/R</code>，不改变 <code>d/v</code>；想减小 <code>d/v</code>，得缩短实际路径</strong>——换更近的区服、或者走更优的路由。</p>
<hr />
<h2>原文里几处需要拧紧的说法</h2>
<p>初稿是照着笔记直接写的，回头核对时发现有四处结论下得太满，一处比喻用错了。留在这里，比悄悄改掉更诚实。</p>
<table>
<thead>
<tr>
<th>初稿的说法</th>
<th>问题</th>
<th>更正后</th>
</tr>
</thead>
<tbody>
<tr>
<td>「带宽就是车道宽度，车道越宽，同一辆车跑得越快」</td>
<td>把发送时延和传播时延混成了一个。车道宽不等于车速快。</td>
<td>带宽提高的是<strong>单位时间能推上链路的比特数</strong>（像传送带变宽，一批货出门更快），信号在光纤里的速度始终不变。</td>
</tr>
<tr>
<td>「传播时延是物理定值，宽带、加速器都无法优化」</td>
<td>定值的是<strong>传播速度</strong>，不是<strong>传播时延</strong>。</td>
<td>光速上限破不了，但<strong>距离可以变</strong>。加速器/专线的作用之一正是换一条更短、更干净的路由，既降 <code>d/v</code>，也避开公网拥塞节点降排队时延。</td>
</tr>
<tr>
<td>「卡顿 90% 是排队时延抖动导致，和带宽大小无关」</td>
<td>「90%」没有来源；「和带宽无关」方向反了一半。</td>
<td>带宽不足导致链路长期饱和，恰恰是排队时延飙升的常见成因。准确说法是：游戏本身码率极低，所以在<strong>链路没被占满</strong>时，单纯升级带宽几乎不改善延迟。</td>
</tr>
<tr>
<td>「稳定高延迟大多是传播时延导致」</td>
<td>归因过窄。</td>
<td>跨区跨洲时确实主要是它；但接入网类型（4G/5G、卫星、DSL 交织）、bufferbloat 造成的固定排队、QoS 整形、服务器自身处理与 tick，都能造成稳定的高延迟。</td>
</tr>
<tr>
<td>「处理时延可以近似忽略」</td>
<td>缺条件。</td>
<td>在普通硬件、无复杂策略时成立；软路由、隧道封装、DPI、高 PPS 小包场景要重新算。</td>
</tr>
<tr>
<td>「排队时延是笼统等待时间」属于错误认知</td>
<td>判得太重。</td>
<td>它确实是拥塞导致的等待，只是说法不完整；准确的说法要补上「发生在输出端口队列、位于处理之后发送之前」。</td>
</tr>
</tbody>
</table>
<p>另外还有一句初稿写得太绝对：「ping 不高但瞬移，就是网络抖动」。网络抖动是主因，但<strong>不是唯一原因</strong>：客户端预测与服务器回滚（lag compensation）在丢包/抖动时会把角色「拉」回权威位置，看起来就是瞬移；本地掉帧、服务器 tick 率低也能造成类似观感。把锅全给网络，排查时容易漏掉另外半边。</p>
<hr />
<h2>真卡了，按这四段去定位</h2>
<p><img src="./images/04-diagnosis.svg" alt="按症状反推是哪一段时延出问题" /></p>
<p>落到操作上，我的排查顺序是这样：</p>
<ul>
<li><strong>延迟一直高，但很稳</strong>（比如固定 180ms）→ 先看传播时延。服务器是不是在另一个大区？换区服、换线路是最直接的。</li>
<li><strong>延迟忽高忽低、人瞬移、技能按不动</strong> → 先怀疑排队时延。看一眼是不是有人在上传/下载，把上行占满了；家里路由器有没有开 QoS / SQM；能插网线就别用 Wi-Fi（无线丢包和重传是另一层问题）。</li>
<li><strong>下载慢，游戏却还行</strong> → 这是吞吐问题，不是时延问题。加带宽有效，但别指望它治瞬移。</li>
<li><strong>看平均值没用，要看波动和丢包率</strong>。连续 ping 或游戏内网络统计里的 jitter / loss，比一个 32ms 有信息量得多。</li>
</ul>
<p>一句话收束：<strong>带宽决定你能多快搬完一批数据，排队时延决定稳不稳，传播时延决定下限在哪。</strong> 三者不是一回事，也不能互相替代。</p>
<hr />
<h2>收尾</h2>
<p>回到开头那个 32ms。它大概率没错，只是它描述的是「平均往返」，而我当时真正被影响的，是排队时延的波动和随之而来的丢包。</p>
<p>四个词背下来不难，难的是<strong>遇到问题时会问「哪一段在变」</strong>。能分清这个，就不太会再把「加个带宽」当成万能解了。下次听人说「延迟高就是网不好」，可以想想：说的是传播下限、队列波动，还是本地帧率？——能分开，说明真的理清了。</p>
<hr />
<p><em>以上是我按教材和公开资料整理的笔记。本次联网核验未成功（本地代理端口未监听），文中数值为按公式手工推算，量级用于建立直觉，具体网络以实测为准。不同接入方式、不同游戏的状态同步实现会有差异，有不对的地方欢迎指正。</em></p>
]]></content>
    <author><name>蓝色玫瑰天上飞</name></author>
    <category term="Knowledge"/>
  </entry>
  <entry>
    <title>解释型语言和编译型语言，我把它理清了</title>
    <link href="https://amancando.xyz/posts/%E8%A7%A3%E9%87%8A%E5%9E%8B%E8%AF%AD%E8%A8%80%E4%B8%8E%E7%BC%96%E8%AF%91%E5%9E%8B%E8%AF%AD%E8%A8%80/" rel="alternate" type="text/html"/>
    <id>https://amancando.xyz/posts/%E8%A7%A3%E9%87%8A%E5%9E%8B%E8%AF%AD%E8%A8%80%E4%B8%8E%E7%BC%96%E8%AF%91%E5%9E%8B%E8%AF%AD%E8%A8%80/</id>
    <published>2026-03-01T00:00:00.000Z</published>
    <updated>2026-03-01T00:00:00.000Z</updated>
    <summary>了解解释型语言和编译型语言。</summary>
    <content type="html"><![CDATA[<h1>解释型语言和编译型语言，我把它理清了</h1>
<blockquote>
<p>这篇是我学完相关章节后整理的笔记。一开始我也觉得「Python 是解释型、C 是编译型」背下来就完事了，直到被一个问题问住：Java 到底算哪边？查了一圈才发现，这两个词没有课本里那么简单。写下来既是给自己留个底，也希望对同样刚接触这块的同学有点用。</p>
</blockquote>
<hr />
<h2>我是怎么被绕进去的</h2>
<p>上学期学 Python，跑代码就一行命令：</p>
<pre><code>python main.py
</code></pre>
<p>不用先编译，改完直接跑，爽。</p>
<p>后来 C 语言课要求先 <code>gcc</code>，再 <code>./a.out</code>，少一步都不行。老师说是「编译型」，Python 是「解释型」——我记下了。</p>
<p>直到某次刷题，有人评论说「Java 也是编译型啊」，底下又有人回「Java 不是跑在 JVM 上吗，算解释吧」。我盯着屏幕看了半天，发现<strong>我背的标签，好像没法干净地贴到具体语言上</strong>。</p>
<p>于是重新查资料、对照几种语言的实际运行方式，有了这篇笔记。</p>
<hr />
<h2>先用一个不太严谨但好懂的比喻</h2>
<p>把「程序」想成一篇中文稿子，「电脑」想成只懂 0 和 1 的听众。</p>
<p><strong>编译型</strong>像：先把整篇稿子翻译成英文，印成册子。之后谁读都直接翻书，不用再翻译。改一个字？重新翻译、重新印。</p>
<p><strong>解释型</strong>像：现场配同声传译，你说一句他译一句。改稿方便，随时能换，但传译本身要时间；同一段反复讲，可能反复做类似工作。</p>
<p>真实语言很少纯走某一端，大多在中间，或者两边都沾。</p>
<hr />
<h2>编译型：先把代码变成「能直接跑的东西」</h2>
<p>C、C++、Go、Rust 这类，典型流程是：</p>
<pre><code>你写的源码  →  编译器  →  机器码（可执行文件）  →  CPU 执行
</code></pre>
<p><code>gcc hello.c</code> 之后得到 <code>a.out</code> 或 <code>hello.exe</code>，运行时<strong>一般不再需要编译器</strong>（静态链接、同一平台的前提下）。</p>
<p>我感受到的几个点：</p>
<p><strong>跑起来通常更快。</strong> 该干的翻译活提前做完了，CPU 执行的是原生指令。操作系统底层、游戏引擎、嵌入式，对性能要求高，这类语言依然常见。</p>
<p><strong>改代码后要重新编译。</strong> C++ 大项目改一行全量编一遍，等几分钟不稀奇。所以工程上才那么在意增量编译、怎么拆模块——跟语言特性绑在一起。</p>
<p><strong>部署相对省心。</strong> 编译出一个 binary 丢上去就能跑（当然得匹配操作系统和 CPU 架构，x86 和 ARM 不是一回事）。</p>
<hr />
<h2>解释型：边翻译边执行</h2>
<p>传统说法里，Python、Ruby、PHP 属于这类。印象中的流程：</p>
<pre><code>源码  →  解释器读入  →  当场翻译并执行
</code></pre>
<p><code>python main.py</code> 不用单独生成 <code>.exe</code>，解释器自己上场。</p>
<p><strong>开发体验好。</strong> 改完保存再跑，反馈快。写脚本、做小工具、验证想法，这点我感触很深——这也是很多课先用 Python 的原因之一。</p>
<p><strong>运行时多一层开销。</strong> 同样逻辑，纯解释执行往往比编译好的 native code 慢。注意是「往往」，不是铁律。</p>
<p><strong>分发的是源码（或中间产物），不是单一 exe。</strong> 给别人 Python 项目，对方环境也得有 Python。和「扔一个可执行文件过去」是两种思路。</p>
<hr />
<h2>真正容易搞混的地方</h2>
<p>如果只记「Python 解释、C 编译」，考试可能够，理解语言行为却不够。下面几个是我查资料时帮助最大的。</p>
<h3>Java：编译了，但不是直接变成机器码</h3>
<p>Java 先编译成<strong>字节码</strong>（<code>.class</code>），再在 JVM 里跑。JVM 还会对热点代码做 <strong>JIT（即时编译）</strong>，把字节码进一步变成机器码。</p>
<p>所以 Java 不是「纯解释」，也不是「纯 AOT 编译成 exe」。更准确的说法：<strong>先编译成中间格式，也就是.class文件。运行时由 JVM 决定怎么执行</strong>。C# + .NET 类似。</p>
<h3>JavaScript：感觉不用编译，其实引擎里忙得很</h3>
<p>早期 JS 真是读一行跑一行。现在 Chrome 的 V8、Node.js 都会先把 JS <strong>编译成字节码甚至机器码</strong>，热路径上 JIT 优化。</p>
<p>我们写 JS 觉得「保存刷新就行」，是因为<strong>编译发生在运行时，对我们透明了</strong>。不等于它只是「解释型」就完事。</p>
<h3>Python：也不只是「打开 .py 就跑」</h3>
<p>CPython 执行前会把源码<strong>编译成字节码</strong>，<code>__pycache__</code> 里的 <code>.pyc</code> 就是这个。只是这一步通常自动完成，不像 C 那样我们手动跑 <code>gcc</code>。</p>
<p>还有 PyPy 这种带 JIT 的实现，性能可以接近编译型语言，只是生态和兼容性有取舍——知道有这回事就行。</p>
<h3>Go：编译型，但编译速度被刻意做快了</h3>
<p>Go 走 AOT 编译，产出单一可执行文件，部署方便。它的编译器设计得够快，所以「编译型 = 编译一定很慢」在 Go 上不完全成立。</p>
<hr />
<h2>一张表，帮助建立直觉（不是标准答案）</h2>
<table>
<thead>
<tr>
<th></th>
<th>C / Go / Rust</th>
<th>传统印象里的 Python</th>
<th>Java / JS / Python3</th>
</tr>
</thead>
<tbody>
<tr>
<td>运行前有没有单独的「编译」步骤</td>
<td>有，生成可执行文件</td>
<td>看起来没有</td>
<td>有，但产物多是字节码</td>
</tr>
<tr>
<td>谁把代码变成能执行的指令</td>
<td>编译器，运行前</td>
<td>解释器，运行时</td>
<td>两者都有，运行时还有 JIT</td>
</tr>
<tr>
<td>改完代码</td>
<td>重新编译</td>
<td>直接再跑</td>
<td>看语言，Java 要重新 javac</td>
</tr>
<tr>
<td>性能（泛泛而谈）</td>
<td>通常更好</td>
<td>通常稍慢</td>
<td>看 JVM/V8 优化，差距可以很小</td>
</tr>
</tbody>
</table>
<p>这是<strong>建立直觉</strong>用的，不是定律。真要比性能，得 profiling，别凭语言标签猜。</p>
<hr />
<h2>我现在的理解：别问「是哪种型」，问三个问题</h2>
<p>教材爱出二选一，好记也好考。实际更值得想的是：</p>
<ol>
<li><strong>什么时候翻译？</strong> 运行前（AOT）、运行时（JIT），还是边跑边译？</li>
<li><strong>翻译成什么？</strong> 机器码、字节码，还是内部结构？</li>
<li><strong>谁来做？</strong> 独立编译器、虚拟机，还是语言内置引擎？</li>
</ol>
<p>把这三个问题想清楚，比背「Python 是解释型」有用得多。我后来再看 GIL、JVM warmup、JS 事件循环，都顺一些——它们都和「代码怎么被执行」有关。</p>
<hr />
<h2>对和我一样在学的人，这知识怎么用</h2>
<p><strong>选语言或做项目时</strong>，我试着少问「编译还是解释」，多问：</p>
<ul>
<li>瓶颈在哪？如果主要是等网络、读数据库，语言差异可能没那么大。</li>
<li>部署环境能装运行时吗？有些嵌入式场景只能 C。</li>
<li>更在意开发速度，还是运行效率？</li>
</ul>
<p><strong>学第二门语言时</strong>，理解执行模型，能少很多「为什么这门语言这样设计」的困惑。这不是背概念，是换角度看问题。</p>
<p><strong>如果被问到</strong>，我会说：传统上分编译型和解释型，但很多现代语言是混合的。Java 编译成字节码在 JVM 上跑还有 JIT；JS 在 V8 里也会编译优化。更准确的问法是：<strong>什么时候、用什么方式，把源码变成可执行指令</strong>。</p>
<hr />
<h2>收尾</h2>
<p>回到开头：Python 是不是因为「解释型」所以简单？</p>
<p>我觉得<strong>简单主要是因为语法、内置类型、库多</strong>，跟「解释型」这个标签关系不大。解释型带来的，更多是<strong>改完就能跑、反馈快</strong>；编译型带来的，更多是<strong>运行效率、资源可控、部署形态清晰</strong>。</p>
<p>两个标签是起点，不是终点。下次听人说「解释型就是慢」，可以想想：说的是 CPython 纯解释，还是 V8 里的 JS，还是 PyPy？——能分清，说明真的理解了。</p>
<hr />
<p><em>以上是我根据课程和资料整理的笔记，不同语言版本、不同引擎实现会有差异，细节以官方文档为准。有不对的地方欢迎指正。</em></p>
]]></content>
    <author><name>蓝色玫瑰天上飞</name></author>
    <category term="Knowledge"/>
  </entry>
  <entry>
    <title>我的第一篇博客文章</title>
    <link href="https://amancando.xyz/posts/%E5%88%9D%E6%9D%A5%E4%B9%8D%E5%88%B0/" rel="alternate" type="text/html"/>
    <id>https://amancando.xyz/posts/%E5%88%9D%E6%9D%A5%E4%B9%8D%E5%88%B0/</id>
    <published>2026-02-11T00:00:00.000Z</published>
    <updated>2026-02-11T00:00:00.000Z</updated>
    <summary>这是我新博客的第一篇文章。</summary>
    <content type="html"><![CDATA[<p>测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试</p>
]]></content>
    <author><name>蓝色玫瑰天上飞</name></author>
    <category term="Knowledge"/>
  </entry>
</feed>
