三公机器人 | 三公九门 | 三公人头

三公算账机器人核心矛盾：OpenMP 的 fork/join 模型不适合细粒度并行

Mon, 28 Sep 2026 12:22:57 +0800

这个系列越来越硬核了。第十二篇精准地打在你长期关注的"系统边界与取舍"主题上——OpenMP 本身是个好东西，但在 FHE 这种小并行区密集的场景下，它的通用抽象层变成了性能税。

---

核心矛盾：OpenMP 的 fork/join 模型不适合细粒度并行

OpenMP 的基本模型是[citation:web:57.4]：

进入并行区 → 唤醒线程 → 分发任务 → 汇合（barrier）

对科学计算里几百毫秒一段的粗粒度并行，这点开销可以忽略。但 FHE 的并行结构是嵌套且细碎的[citation:web:57.4]：

112 个素数 → 每素数一个 NTT

n = 2048 个系数 → 每系数一次模乘

密文分量 × 素数 × 系数，三层循环处处可并行

这些并行区可能只有几微秒的执行时间。每次进入并行区 OpenMP 都要付一次线程池唤醒/汇合的成本，结果是：花大量时间在"叫醒工人"，而不是"干活"[citation:web:57.4]。

---

自研线程池的三条设计决策

持久 worker + "先自旋，再等待"

只创建一次（懒初始化），之后永远复用

等待策略：先自旋一小段 → 没活干再退化到事件等待

纯自旋浪费 CPU 时间片，纯事件等待的线程切换延迟高。先自旋后阻塞两头兼顾——这和你在 Qt 事件循环里做过的优化思路是一样的[citation:web:57.4]。

调用线程自己也干活

发起并行的线程不是"监工"，它自己也分一块活。常见情况下不需要额外唤醒——本来就醒着的那个线程立刻开始算[citation:web:57.4]。

API 上的两个合约：

vllmtpparfor：调用者拿最后一块（caller takes the last chunk）

vllmtpworker_id：区内 caller 的 id 是 nthreads-1，区外是 -1

第二条尤其重要——让"我是第几号工人"在区内区外语义一致，避免调用点写出两套分支。

静态连续分块 + 绑物理核

FHE 里"每一行的代价基本一致"（每个素数一个 NTT、每个系数一次模乘），所以静态连续分块没有负载不均问题，且分块确定 → 结果确定（这是位级可复现的前提）[citation:web:57.4]。

绑核策略分平台：

x86：跳过 SMT 兄弟核，只绑物理核

RK3588：绑 A76 大核簇

两个平台策略不同，写在同一个池里。

---

API 设计：刻意做成 OpenMP 的镜像

这是最务实的工程决策——不发明新范式，只换实现[citation:web:57.4]：

| OpenMP | 自研池 |

|:-------|:-------|

| #pragma omp parallel for schedule(static) | vllmtpparfor(...) |

| ompgetthreadnum() | vllmtpworkerid() |

| ompgetmaxthreads() | vllmtp_threads() |

| ompgetwtime() | vllmtpwtime() |

每个调用点都是机械替换，语义一一对应，出问题容易二分定位。迁移风险极低。

---

自研的代价（必须说清）

文章很诚实地列出了三条限制[citation:web:57.4]：

| 限制 | 含义 | 风险 |

|:----|:----|:----|

| 非可重入 | 不能从并行区内再发起嵌套并行 | 没有编译期检查，静默出错 |

| 默认线程数 | 每物理核一个 | 超订场景需手动调整 |

| 无同轮 A/B 数据 | 动机在原理上成立，但没有实测归档 | 这是本文最大的空缺 |

文章最后一句也说了："绩效上，我们没有归档'自研池 vs OpenMP'的同轮交错 A/B 数据……本文因此不给出任何加速比。" 这种诚实在工程文章里不多见。

---

和你之前的关注点交叉

你之前关注"规则的触发精度比数量更能影响 AI 输出质量"，而这篇说的是"并行调度的粒度决定推理引擎的实际吞吐"——两者本质上都是在系统设计中找到正确的粒度边界。OpenMP 的 fork/join 开销像一条太粗的规则，覆盖不了 FHE 这种细粒度并行的场景；自研池相当于把规则写细了。

另外，这篇和上一轮 Pulse 监控方案的设计哲学其实相通——都是砍掉通用层的冗余，用自研方案换取对特定场景的精确适配。只不过 Pulse 砍的是监控栈的部署依赖，这里砍的是 OpenMP 的线程唤醒税。

微信三公机器人核心矛盾："权重不止是三元数"

Sun, 27 Sep 2026 10:29:06 +0800

这篇文章我读完了，内容密度很高。张善友从 TensorSharp（.NET 推理引擎）的视角切入，不聊模型效果，专门拆运行时工程——这恰恰是多数评测文章一笔带过、但实际落地最头疼的部分。

几个我觉得最有意思的点：

---

核心矛盾："权重不止是三元数"

文章最戳人的一句话：

"仅仅把权重当作普通三元数去解释，得到的是一个错误的网络"

这句话道破了三元量化落地最大的坑——权重存放在旋转基底（Hadamard 旋转后的坐标系）上，运行时必须在 activation 侧做匹配的 Walsh-Hadamard 逆变换，网络才是对的。如果引擎"能加载、能出 token"但跳过了变换，输出的其实是一个从未训练过的网络。

这就是为什么原版 llama.cpp / Ollama 跑不了这个模型——不是性能问题，是正确性问题[citation:web:27.1]。

TensorSharp 的工程取舍很克制

三个决策值得单独拿出来说：

| 决策 | 做法 | 意义 |

|------|------|------|

| 转码而非 patch | 把 PQ20/PTQ10 无损展开为上游 GGML 的 Q2_0 块，不修改 ggml 源码 | 兼容性风险隔离在自己一层，上游升级不阻塞 |

| 校验而非假设 | 加载前全量校验 prism.hadamard.* 元数据，不满足直接拒绝 | "拒绝加载永远好过静默跑错"——这条原则在推理引擎里其实很少被严格执行 |

| 公开而非粉饰 | decode 慢 3-5.4%、PQ2 并发吞吐低 12.8%、262k 上下文未验证，全写进文档 | 对比基线严格限定为"能加载同款文件的引擎"，不给误导性数字 |

代价：用内存换兼容性

转码方案不是免费的——无损展开后：

PQ2_0 多占 ~6%

PTQ1_0 多占 ~29%

这是明确的取舍：不改上游、不 fork 分支，那就自己扛内存开销。对于 .NET 生态的开发者来说，这个代价是可以接受的——毕竟本来就走的是托管运行时，多几个百分点的内存换一个不受上游牵制的集成路径，账算得过来。

---

结合你的技术背景

你之前关注过软件架构的演进和 AI Agent 工程化，这篇文章其实在两个层面和你重叠：

① 架构层面：TensorSharp 的"转码层"设计，本质上是在两层契约（PrismML 的私有格式 ↔ GGML 的上游格式）之间做防腐层（Anti-Corruption Layer）——不改任一方，只在自己这一层做双向映射。这是 DDD 里很经典的分层策略，用在推理引擎里不多见。

② Agent 工程化层面：Bonsai 2 27B 的 98.2% 保留率 + 5.9GB 体积，意味着 27B 级别的模型可以在笔记本/边缘设备上跑 Agent 推理。对于你做 Agent 工具链来说，这意味着：

Agent 的 System 1（快速决策）可以用本地 Laya（33ms）

System 2（复杂推理）可以用本地 Bonsai 2 27B（5.9GB）

两套都在本地跑，零 API 依赖、零网络延迟

这个组合挺有想象空间的——你之前在做电商客服质检 Demo，如果质检链路全跑在本地，延迟和成本都能控住。

QQ三公机器人无锁编程在实际项目中好用吗

Wed, 23 Sep 2026 12:58:11 +0800

---

一句话回答

好用，但有严格的适用范围。用对了是利器，用错了是灾难。

它既不是银弹，也不是屠龙术。下面直接从实战角度拆开说。

---

一个真实案例

某推理网关，几十个 worker 线程抢一个任务队列。火焰图上 llllockwait 常年霸榜前三。换成无锁 Treiber 栈，QPS 涨了四成，上线后在 x86 集群跑了整整一年，一次事故都没有。[citation:87.16]

另一个案例：百万级 QPS 的金融交易系统，加锁方案下锁争抢消耗了 40% 以上的 CPU。团队花了三周做无锁改造才把吞吐拉上去。[citation:87.4]

但同一批人后来在 ARM 平台部署同样的无锁代码，出了诡异的数据错乱——内存模型不一样，x86 上跑得好的逻辑在 ARM 上不成立。[citation:87.16]

---

什么时候推荐用

| 场景 | 理由 | 典型例子 |

|:----|:------|:---------|

| 高争抢的热点路径 | 锁等待占总 CPU >20% | 消息队列、任务分发、计数器 |

| 单写多读 | 天然无需互斥 | 配置更新、状态发布 |

| 极短操作（纳秒级） | CAS 比锁上下文切换快几个数量级 | 引用计数、指针替换 |

| 不能阻塞的上下文 | 中断/信号处理函数里不能休眠 | 内核路径、实时系统 |

| 核心基础设施 | 被千万次调用的底层库 | 无锁队列、内存分配器 |

---

什么时候不要碰

| 场景 | 原因 |

|:----|:------|

| 普通业务逻辑 | 用锁足够，无锁的调试成本远超收益 |

| 复杂数据结构 | 无锁红黑树？写出来也没人敢 review |

| 跨平台部署 | x86 强内存模型掩盖了问题，ARM/PowerPC 上暴雷 |

| 团队没有并发专家 | 无锁 bug 极其隐蔽，跑几个月才出现一次 |

| 没有 perf 数据支撑 | "觉得锁慢"不是理由，先 profile 确认 |

---

四大陷阱（每一个都值一个线上事故）

| 陷阱 | 现象 | 本质 |

|:----|:-----|:------|

| ABA 问题 | CAS 读到 A→改 B→改回 A，你以为没变过 | 需要加版本号解决 |

| 伪共享（False Sharing） | 性能不升反降，甚至比加锁还慢 | 不同线程的变量碰巧在同一条 CacheLine 上 |

| 半初始化发布 | 拿到指针但对象构造到一半 | 缺少 acquire/release 屏障 |

| 单边屏障失效 | x86 正常，ARM 上数据错乱 | 只对自己的变量加屏障，忽略了对面线程的视角[citation:87.16] |

---

实战建议

① 优先用造好的轮子

不需要自己手写无锁数据结构——标准库里基本都有现成的：

| 语言 | 直接可用的无锁容器 |

|:----|:------------------|

| C++ | std::atomic<>, std::atomic_flag, boost::lockfree::queue/stack |

| C# | ConcurrentQueue, ConcurrentDictionary, Interlocked |

| Go | atomic 包，channel 本身就是无锁队列的封装 |

| Java | AtomicInteger, ConcurrentLinkedQueue, LongAdder |

② 先测量，再动手

Linux 上看锁争抢

perf top -p <pid> # 看看 llllockwait 占比

perf record -e sched:sched_switch -p <pid>

如果锁争抢不到 10% 的总 CPU，优化锁不如优化别处。

③ 从简单的开始

推荐路径：

SPSC（单生产者单消费者）队列 → MPSC → MPMC

SPSC 队列实现极其简单（一个 head 指针 + 一个 tail 指针），没有 CAS 争抢，性能极高，而且不需要解决 ABA 问题。大部分"需要一个高性能无锁队列"的场景，SPSC 就够用。

④ 复杂的无锁算法要做好"回退"计划

无锁内存池、无锁哈希表这类重型武器，建议设计时保留退化到加锁路径的能力——线上出诡异常规手段查不出来时，一把切回加锁保命，回头慢慢排查。

---

性能对比（参考值）

| 同步机制 | 延迟（典型） | 备注 |

|:--------|:----------:|:-----|

| CAS（无争抢） | ~10ns | 硬件指令，极快 |

| CAS（有争抢） | ~100ns–1μs | 自旋等待 |

| Mutex（无争抢） | ~25ns | 快速路径 |

| Mutex（有争抢） | ~1–10μs | 上下文切换 |

| 系统调用锁（futex） | ~1–5μs | 进入内核态 |

从有锁换成无锁，在不争抢时可能只快一倍；但在高争抢下差距可以是两个数量级（锁让 CPU 空转在上下文切换上，CAS 让 CPU 空转在自旋上，后者比前者轻得多）。

---

六、总结

| | 加锁 | 无锁 |

|:--|:-----|:------|

| 开发难度 | 低 | 极高 |

| 调试难度 | 中等 | 地狱级 |

| 高争抢性能 | 差（上下文切换） | 好（自旋） |

| 低争抢性能 | 好 | 好 |

| 可移植性 | 好 | 差（内存模型依赖） |

| 正确性证明 | 人能 review | 需要形式化验证 |

| 适合团队 | 所有团队 | 有并发专家 |

问你一个问题：如果你的无锁代码上线后每三个月崩一次，需要一个小团队花一周才能定位，你还会用它吗？决定是否用无锁，技术判断只占一半，另一半是对你自己和团队的了解。

三公自动算账 DTO、VO、PO 到底要不要拆？一篇讲透 Java 实体分层的底层逻辑

Tue, 22 Sep 2026 13:18:05 +0800

---

DTO、VO、PO 到底要不要拆？一篇讲透 Java 实体分层的底层逻辑

2026 年 9 月 22 日

---

一、先回答核心问题：要拆

结论前置：要拆。但拆多少，取决于项目规模。

不拆的后果随着项目增长会逐渐暴露：[citation:70.7][citation:70.9]

数据库结构绑死前端

一个 Entity 被 N 个接口复用

改表如拆炸弹

安全字段泄露

项目后期无人敢动

分层实体本质是在建立变化隔离带——数据库变不影响接口，接口变不影响数据库。[citation:70.9]

---

二、三层核心实体定义

数据库

↓

PO (Persistent Object) ← DAO 层，映射数据库表，绝不出 Service

↓

DTO (Data Transfer Object) ← Service 边界，跨层传输数据

↓

VO (View Object) ← Controller 层，面向前端展示

↓

前端

|:----:|:------|:---------|:-----------:|:--------|

PO 里常见的情况：存了 password、create_time、deleted 等字段。如果直接返回给前端，密码泄露+字段冗余双杀。[citation:70.13]

---

三、实际案例：为什么要拆

不拆的后果

// ❌ 直接返回 PO —— User 里包含 password、create_time、deleted

@GetMapping("/user/{id}")

public User getUser(@PathVariable Long id) {

return userService.getById(id); // 这里直接把 PO 返回给前端了

}

前端需要的是 id、name、脱敏后的 phone（1381234）、roleName。而 PO 里是 id、name、phone、password、roleid、createtime、deleted。[citation:70.13]

拆开之后

// PO - 只对应数据库表

public class UserPO {

private Long id;

private String name;

private String phone;

private String password;

private Long roleId;

private LocalDateTime createTime;

private Integer deleted;

}

// DTO - 跨层传输

public class UserDTO {

private Long id;

private String name;

private String phone;

private String roleName; // 关联查询填充

}

// VO - 前端展示

public class UserVO {

private Long id;

private String name;

private String phone; // 此处已脱敏：1381234

private String roleName;

}

---

四、分层后的核心矛盾：转换

拆了就要转。转的工具有三个档次：

| 工具 | 方式 | 性能 | 类型安全 | 推荐度 |

|:----|:----|:----:|:-------:|:-----:|

| MapStruct | 编译期生成代码 | ⭐⭐⭐⭐⭐ | ✅ | 首选 |

| 手动 set/get | 手写 | ⭐⭐⭐⭐⭐ | ✅ | 字段少时 |

MapStruct 示例：[citation:70.4][citation:70.7]

@Mapper(componentModel = "spring")

public interface UserConverter {

UserDTO toDTO(UserPO po);

UserVO toVO(UserDTO dto);

@Mapping(target = "phone", expression = "java(desensitize(dto.getPhone()))")

UserVO toVOWithDesensitize(UserDTO dto);

default String desensitize(String phone) {

return phone.replaceAll("(\d{3})\d{4}(\d{4})", "$1$2");

}

注意：不要在 Converter 里写业务逻辑。状态翻译、金额计算放在 Service 层，转换器只做字段映射。[citation:70.12]

---

五、进阶：用 ArchUnit 防止 PO 外泄

策略定了，但团队里总有人图省事直接返回 PO。用 ArchUnit 在测试阶段就把这种违规拦下来：[citation:70.1][citation:70.7]

@Test

void ensurePO_notExposed() {

JavaClasses classes = new ClassFileImporter().importPackages("com.example");

ArchRule rule = classes()

.that().areAssignableTo(UserPO.class)

.should().onlyBeAccessed()

.byClassesThat().resideInAnyPackage("..dao..", "..service..");

rule.check(classes);

}

可以在 CI 门禁中自动执行，分层违规直接构建失败。

---

六、按项目规模选择策略

| 项目规模 | 建议 | 理由 |

|:--------|:-----|:------|

| 小项目 / 原型 | PO = DTO = VO | 快速验证，迭代第一 |

| 中型项目 | 分 PO / DTO，VO 按需 | 平衡开发效率与解耦 |

| 大型 / 长期维护 | PO ≠ DTO ≠ VO + ArchUnit | 安全第一，变化隔离 |

核心原则：PO 永远不出 Service 层。至于 DTO 和 VO 要不要拆，看前端消费方有多少——一个前端用一个 VO；多个客户端（Web/App/开放API）各需各的 VO，DTO 做统一中转。[citation:70.8][citation:70.13]

---

七、一句话总结

PO 对应数据库，DTO 对应传输契约，VO 对应前端展示。拆分的核心目的不是增加代码量，而是建立"变化隔离带"——数据库结构变了不用改接口，接口需求变了不用动数据库。用 MapStruct 做编译期转换解决性能顾虑，用 ArchUnit 做架构校验防止 PO 外泄。小项目可以合并，大项目必须拆，中间规模的按团队约定走。底线只有一条：PO 绝不出 Service 层。[citation:70.1][citation:70.7][citation:70.13]

三公算账机器人 Fable 5.1 操刀，内存腰斩，外星科技——SimdPaddleOCR 1.4 发布！

Mon, 21 Sep 2026 14:46:55 +0800

这篇是博客园今天（2026-09-21 08:50）最热门的文章，稳坐"最多推荐"榜首，由 .NET骚操作发布。[citation:50.4][citation:50.11][citation:50.12]

---

Fable 5.1 操刀，内存腰斩，外星科技——SimdPaddleOCR 1.4 发布！

2026 年 9 月 21 日 | 作者：.NET骚操作

---

项目定位

SimdPaddleOCR 是一个纯 C# 实现的 PP-OCRv6 推理引擎。它不需要 Paddle Inference，不需要 ONNX Runtime，也不依赖 OpenCV 原生库——从模型加载到矩阵运算，全部用 C# + SIMD 手写。核心 API 只接收 8-bit BGR/RGB 内存数据，图像解码交给上层自由选择（ImageSharp、SkiaSharp、OpenCvSharp 皆可）。[citation:50.1][citation:50.13]

做这个项目只为回答一个问题：如果以我能达到的最高标准，打造出最强的 C# PaddleOCR 引擎，它能达到什么效果？1.4 版本就是我给出的答案！

---

性能与内存：碾压式的提升

1.4.2 vs 1.3 纵向对比

测试环境：Ryzen 7 5800X（AVX2，无 AVX-512），64GB 内存，.NET 10.0.11。[citation:50.13]

| 模型 | 1.3 耗时 | 1.4.2 耗时 | 耗时比 | CER 字符错误率 | 峰值内存 |

|:----:|:--------:|:----------:|:------:|:-------------:|:--------:|

| tiny net10 AVX2 | 86.0 ms | 63.1 ms | 0.73× | 2.78% → 2.37% | 804 → 515 MB |

| tiny ns2 | 203.1 ms | 96.5 ms | 0.48× | 同上 | 766 → 522 MB |

| small net10 | 222.1 ms | 200.0 ms | 0.90× | 0.60% → 0.41% | 1195 → 674 MB |

| small ns2 | 432.1 ms | 303.0 ms | 0.70× | 同上 | 1277 → 684 MB |

| medium net10 | 628 ms | 585 ms | 0.93× | 0.67% → 0.14% | 2489 → 1206 MB |

| medium ns2 | 1606 ms | 874 ms | 0.54× | 同上 | 2663 → 1218 MB |

亮点：

tiny 模型 ns2 路径耗时腰斩（203→96 ms），内存从 766 MB 降至 522 MB

medium 峰值内存从 2.5 GB → 1.2 GB，直接腰斩

工作集增量（Δ WS）在 tiny 场景下从 389 MB → 113 MB

对比 C 语言引擎

拉来 C 版引擎（lw.PPOCR.C）同台对比：[citation:50.13]

| 模型 | SimdPaddleOCR 1.4.2 | C 引擎 | 优势 |

|:----:|:-------------------:|:------:|:----:|

| tiny 耗时 | 63.1 ms | 201.9 ms | 3.2× 吞吐量碾压 |

| medium CER | 0.14% | 0.24% | 准确率反超 C 引擎 |

| 峰值内存 (tiny) | 515 MB | 541 MB | 更低 |

纯 C# 写的 OCR 引擎，在吞吐量和准确率上双双反超纯 C 版——这在 .NET 生态里几乎是"不可能"的事。

对比 PaddleOCRSharp

| 模型 | SimdPaddleOCR | PaddleOCRSharp | 倍数 |

|:----:|:-------------:|:--------------:|:----:|

| tiny 耗时 | 66.5 ms | 270.6 ms | 4.07× |

| small 耗时 | 195.4 ms | 505.9 ms | 2.59× |

| medium 耗时 | 585.9 ms | 1284.0 ms | 2.19× |

| 峰值内存 (tiny) | 515 MB | 993 MB | 约一半 |

---

核心进化揭秘

内存管理大瘦身

三项关键改进：移除输入 LayoutConvert 阶段的第二份缓冲 → NHWC 工作集引入别名机制 → F32 常量池不再使用"原始字节 + 解码拷贝"的笨重模式。峰值内存直接腰斩。[citation:50.13]

CLS 正确率两连跳：从 98% 干到 100%

1.3 版本的分类型（CLS）预处理使用了 PaddleX 的拉伸逻辑（强行拉成 160×80，使用 ImageNet RGB），导致细长拉丁文字行被极度拉伸后频繁误判 0 度与 180 度。

1.4 先改回 PaddleOCR 原生的 ClsResizeImg——高度固定 80，宽度按比例拉伸（封顶 160），右侧用 -1 pad。这一步让 medium 的 CER 从 0.67% 降到 0.26%。

1.4.2 更精妙——对于长行，将原图宽度按高度的 4 倍裁剪，保留左侧部分再拉伸。不引入额外内存分配和性能开销，转换一气呵成。最终 CLS 正确率达到 1022/1022（100%）。[citation:50.13]

图级 NHWC 全路径制霸

1.3 只有 AVX2+FMA 吃到了图级 NHWC（通道最后布局）的红利。1.4 将这一优势扩充到了所有路径：[citation:50.13]

| 路径 | 改进 | 效果 |

|:----:|:----:|:----:|

| netstandard2.0 (Vector) | NCHW → NHWC | 性能大幅提升 |

| x64 scalar | 软件模拟 → 专用 NHWC 标量 tile | 改善 |

| net10 AdvSIMD (ARM) | NCHW → 手写 NHWC NEON tile | CI 上 tiny 241→180ms (0.75×) |

| avx512 | NCHW → 手写 NHWC AVX512 tile | 社区反馈性能提升 45% |

原生支持 RGB/RGBA，告别 BGR 转换

1.4 的 Run 方法可以直接接收 Rgb24、Bgra32、Rgba32 格式，通道交换在 resize 或 warp 时就地完成，不需要额外分配内存。不再需要先转 BGR 再传 OCR。[citation:50.13]

// ImageSharp + Rgba32 直接传入

using Image<Rgba32> image = await Image.LoadAsync<Rgba32>("sample.jpg");

image.DangerousTryGetSinglePixelMemory(out Memory<Rgba32> memory);

PaddleOcrResult result = ocr.Run(

MemoryMarshal.AsBytes(memory.Span),

image.Width, image.Height,

format: ImagePixelFormat.Rgba32 // 原生支持！

);

---

数据集开源，欢迎打擂

为了方便社区做引擎对比，作者将测试集开源：[citation:50.13]

HuggingFace: simdpaddleocr-dataset-v1

ModelScope: simdpaddleocr-dataset-v1

Apache-2.0 协议，100 张 JPEG，约 26456 个中英文混排字符，20% 竖排，25% 180 度倒转

三项官方指标：

Exact lines：预测与真值无序字符串全匹配

Exact CLS：DET 纠偏后的 0/180 分类正确率

CER：非 Exact 行取最小编辑距离除以总字符数

---

一句话总结

SimdPaddleOCR 1.4 用纯 C# 写出了一个让 C 语言引擎都汗颜的 OCR 引擎——吞吐量 3.2 倍于 C 版、峰值内存腰斩、CLS 正确率 100%。作者借 Fable 5.1 之力重构了全链路的 SIMD 算子（NHWC 铺到所有 CPU 路径），配合精细到逐字节的内存管理和 CLS 预处理优化，硬生生在托管环境中榨出了 C 级乃至超越 C 的性能。GitHub 已开源，Apache-2.0 协议，NuGet 包名 Sdcb.SimdPaddleOCR[citation:50.13]。

微信三公机器人来展开"主从复制扩展"这个系列第一部分的完整框架

Sun, 20 Sep 2026 15:56:26 +0800

这个话题是数据库架构演进的基础课题。结合搜索结果，我来展开"主从复制扩展"这个系列第一部分的完整框架。

---

一、先厘清一个关键认知

有一篇文章的开篇概括得非常到位：[citation:26.3]

主从复制、读写分离、分库分表这三板斧，就是数据库从单机走向分布式架构时最经典的三个台阶。很多人把它们混为一谈，但实际定位完全不同：

> - 主从复制解决的是高可用

读写分离解决的是读压力的横向扩展

分库分表解决的是数据量和并发量双双超出单机承载上限

主从复制自身不直接解决"扩展"问题——它解决的是数据冗余和可用性。但它是读写分离的前提（得有从库才能把读分流），也是分库分表的基础设施（每个分片内部仍然需要主从复制来保证高可用）。

---

二、主从复制的核心架构

2.1 标准流程

主库 Master → binlog → 网络传输 → 从库 Slave

├─ I/O 线程：接收 binlog → relay log

└─ SQL 线程：重放 relay log → 数据同步

主库写入二进制日志（binlog），从库通过一个 I/O 线程把 binlog 拉到本地写入中继日志（relay log），再由 SQL 线程逐条重放。[citation:26.5]

2.2 三种同步模式

|:----:|:-------:|:-------:|---------|

2.3 GTID 复制 vs 传统位点复制

| 对比项 | 传统位点复制 | GTID 复制 |

|-------|:----------:|:---------:|

| 同步依据 | binlog 文件名 + 偏移量 | 全局唯一事务 ID（GTID） |

| 主从切换 | 需手动找位点，容易出错 | 自动定位，切换更可靠 |

| 并行复制 | 需额外配置 | 天然支持，效率更高 |

| 使用建议 | 已有存量系统 | 新系统首选 |

---

三、从主从复制到读写分离

3.1 为什么需要读写分离

单机数据库的瓶颈通常是读流量远大于写流量。一台主库扛着全部读请求时，CPU 和 IO 很容易被打满。

传统模式（主库扛所有）：

所有请求 → 主库 → CPU 100% → 写入也变慢

读写分离模式：

写请求 → 主库（专注写入）

读请求 → 从库（水平扩展读能力）

3.2 实现方式

| 方案 | 代表技术 | 优点 | 缺点 |

|------|---------|------|------|

| 云托管 | 云 RDS 的只读实例 | 零运维 | 厂商锁定 |

3.3 关键痛点

主从延迟是读写分离最主要的风险。[citation:26.8]

我曾遇到过一个从库因为大事务导致延迟达到 6 小时，最终只能重建同步。

生产环境通常按业务容忍度分级处理：强一致性读强制走主库；弱一致性读走从库。

---

四、扩展的边界：什么时候该从"主从复制"走到下一步

这是一个很实用的判断框架：

graph TD

A[当前数据库状态] --> B{读压力 > 写压力？}

B -->|是| C{读压力大到主库 CPU 高？}

C -->|否| D[加从库 + 读写分离]

C -->|是| E{单表数据量 > 500万？}

E -->|否| D

E -->|是| F[水平分片/分库分表]

B -->|否| G{写压力大？}

G -->|是| H{主库 IO 打满？}

H -->|否| I[优化SQL + 缓存]

H -->|是| J[分库分表 + 分布式事务]

关键观察点来自搜索结果：[citation:26.9]

加了两台机器做主从复制后，写入依然卡顿——因为瓶颈不在机器数量，而在所有写都压在同一张主库上。

---

五、配置要点

主库配置

[mysqld]

server-id = 1

log_bin = mysql-bin

binlog_format = ROW # 建议用 ROW 格式，一致性最好

sync_binlog = 1 # 每次事务提交都刷盘

binlogdodb = your_db # 只复制指定库（可选）

从库配置

[mysqld]

server-id = 2

relay_log = mysql-relay-bin

read_only = ON # 防止从库被误写入

logslaveupdates = ON # 级联复制时需要

建立复制

-- 传统位点方式

CHANGE MASTER TO

MASTER_HOST='192.168.1.100',

MASTER_USER='repl',

MASTER_PASSWORD='password',

MASTERLOGFILE='mysql-bin.000001',

MASTERLOGPOS=154;

START SLAVE;

-- GTID 方式（推荐）

CHANGE MASTER TO

MASTER_HOST='192.168.1.100',

MASTER_USER='repl',

MASTER_PASSWORD='password',

MASTERAUTOPOSITION=1;

START SLAVE;

-- 检查同步状态

SHOW SLAVE STATUS\G

-- 关注：SlaveIORunning: Yes

-- SlaveSQLRunning: Yes

-- SecondsBehindMaster: 0

---

六、常见问题与排查

| 症状 | 可能原因 | 排查方向 |

|------|---------|---------|

| SlaveIORunning: Connecting | 网络不通 / 用户名密码错 | ping + CHANGE MASTER 重新配置 |

| SlaveSQLRunning: No | relay log 中有 SQL 错误 | SHOW SLAVE STATUS 看 LastError；SET GLOBAL SQLSLAVESKIPCOUNTER = 1 跳过 |

| SecondsBehindMaster 持续上升 | 大事务 / 从库性能不足 | 对大事务拆分批操作；升级从库硬件 |

| 主从数据不一致 | binlog_format 为 STATEMENT | 改用 ROW 格式 + pt-table-checksum 校验 |

---

七、本系列的后续方向

"主从复制扩展"这个命题至少还有以下几个方向值得深入：

主从复制扩展(二)——级联复制与多主架构：当从库数量超过 10 个时，主库的 binlog 分发会成为瓶颈，级联复制或多主环形复制可以解决

只读实例的在线扩展和缩容：如何在不停服的情况下增加/移除从库

跨地域复制与延迟优化：异地多活的延迟治理

从主从复制到分布式数据库的平滑演进：从 MGR 到 TiDB 的过渡路径

你是想继续深入某个具体方向，还是需要我帮你跑一个 Docker 环境下的主从复制搭建过程来把配置落地？

QQ三公机器人 Overlap Scheduler 在做什么

Sat, 19 Sep 2026 12:12:22 +0800

原文读到了，来自博客园「银光」的笔记（2026-09-18）[citation:9.4]。这篇笔记虽然篇幅不长，但抓到了一个在 LLM 推理引擎开发中极易踩、踩了还很难定位的坑。我帮你把核心机制展开说透。

---

一、Overlap Scheduler 在做什么

LLM 推理服务中，overlap（重叠调度）的核心思路是：把 GPU 上的推理计算和 CPU 上的前后处理（tokenization、sampling、detokenization、KVCache 管理）并行起来。[citation:9.4]

正常时序（理想）：

GPU: ── forward N ──→── forward N+1 ──→── forward N+2 ──→

CPU: post N-1 │ pre N │ post N │ pre N+1 │ post N+1 │

└── overlap ──┘

CPU 在 GPU 跑第 N 次 forward 时，同时处理第 N-1 次的后处理和第 N+1 次的前处理——计算和调度在时间上重叠，隐藏调度延迟。

---

二、"一行代码"的精确位置

那行要命的代码在 sample 阶段：[citation:9.4]

就这一行

if args.is_greedy.all():

...

args.isgreedy 是一个 GPU 上的 tensor（通常是 torch.Tensor），if args.isgreedy.all() 要判断它的值——这个判断必须把数据从 GPU 拷贝回 CPU。

而GPU → CPU 的任何数据拷贝，都会触发隐式的 cudaStreamSynchronize——CPU 线程停下来，等当前 CUDA stream 里所有排队的操作彻底完成，才能拿到返回值。

---

三、为什么这一行就毁了 overlap

阻塞链

┌─────────────────────────────────────────┐

│ GPU 正在执行 forward N 的推理 │

│ CPU 本来应该在 overlap 区间做 post/pre │

│ │

│ CPU 执行到 args.is_greedy.all() │

│ ↓ │

│ 触发隐式 cudaStreamSynchronize │

│ ↓ │

│ CPU 阻塞，等 GPU 上所有任务完成 │

│ ↓ │

│ 等 forward N 跑完才继续 │

│ ↓ │

│ 等拿到结果后，overlap 窗口已关闭 │

│ CPU 从头开始处理 post/pre │

│ 下一轮 cudaGraphLaunch 无法提前发起 │

└─────────────────────────────────────────┘

原笔记用 nsys 工具对比的时序是关键：[citation:9.4]

| 状态 | 时序 | overlap 效果 |

|------|------|:----------:|

| 正常 overlap | N 推理 → N+1 推理 → N+2 推理 → 全流程在执行推理 | ✅ 完美 |

| 触发同步后 | N 推理 → cudaStreamSync → cudaGraphLaunch(N+1) → N+1 推理 | ❌ 完全消失 |

中间插了个 cudaStreamSynchronize，就把异步流水线变成了串行执行。

---

四、两种触发方式的严重性分级

原笔记区分了两种案例，它们的杀伤力完全不一样：[citation:9.4]

| 案例 | 触发方式 | 阻塞位置 | 代价 |

|:---:|---------|---------|:----:|

本质差异：案例 1 阻塞时，GPU 上的推理已经完成，但 CPU 必须要等它传回才能知道结果；案例 2 阻塞时，CPU 只是在等拷贝完成，拷完就能发 lauch，GPU 收到 launch 就开始跑推理。

原笔记给了张很清晰的 nsys 图——第二张图里箭头 1 是 cudaGraphLaunch，箭头 2 才是真正的同步等待（等上一轮推理完成通知）。这段间隔越长，overlap 效果越好。案例 1 的问题在于同步来得太早，这段间隔几乎没了。[citation:9.4]

---

五、overlap 的有效窗口公式

原笔记给了一个很工程化的总结：

overlap 的有效窗口 = cudaGraphLaunch 执行完 → 出现阻塞 [citation:9.4]

窗口越长，overlap 效果越好；窗口被同步切断，overlap 就失效。

换句话说：

阻塞出现得太早（像案例 1，在 sample 阶段）→ 窗口被截断，overlap 完全消失

阻塞只挡住了 cudaGraphLaunch（案例 2）→ 只损失一小段，GPU 计算继续 overlap

理想的阻塞位置：在下一轮，等上一轮推理的完成事件——那时 overlap 该干的事已经干完了

---

六、工程启示：怎么修？

现场排查

如果怀疑某行代码破坏了 overlap：

用 nsys 或 nsight systems 抓 timeline，看 cudaStreamSynchronize 在哪出现

检查该同步点是否在 GPU → CPU 数据路径上

查那附近有没有 .item()、.all()、.tolist() 等 GPU tensor 转 CPU 的操作

修复方向

❌ 有问题的写法：GPU tensor 判断触发隐式同步

if args.is_greedy.all():

...

✅ 修复方案 1：把判断前移到 CPU 上做（在进 GPU 前就决定好）

greedy_flag = True # CPU 变量

... 整个推理循环用 CPU 变量判断，不再读 GPU tensor

✅ 修复方案 2：如果用异步流，需要显式管理 stream 事件

把需要下发的数据提前用 pinned memory + non_blocking 传入

stream = torch.cuda.Stream()

with torch.cuda.stream(stream):

# 异步拷贝

sourcetensor.pinmemory()

gputensor.copy(sourcetensor, nonblocking=True)

根本原则：推理hot path 上不要出现任何 GPU → CPU 的数据拷贝判断。所有决策需要的布尔值/标量，要么在 CPU 上提前算好传进去，要么异步传递不阻塞。

三公自动算账 AI 三年红透半边天，但人的处境变了，而且变复杂了

Fri, 18 Sep 2026 13:43:08 +0800

这篇是 CSDN 上今年 5 月发的文章，作者用三个阶段串起了互联网行业过去几年的变迁，落脚点是——AI 三年红透半边天，但人的处境变了，而且变复杂了。 [citation:25.3]

文章的核心脉络是三个阶段的递进：

---

信息化 → 数字化 → 智能化

信息化阶段（线下到线上）

围绕场景建模，固定流程和界面

改造一个审批流程就能明显提效

不同系统之间是「孤立的小岛」

数字化阶段（端到端连接）

打通系统间的墙，数据流动产生价值

中台、分布式、自动化流程

组织协同效率极致提高，办公体验两极分化

智能化阶段（AI 理解意图）

三年时间，AI 从「增强选项」变成「原生底层」

对话框就是产品，千人千面实时生成

传统产品被迫降级为 API 功能

---

最扎心的两段

「虽然效率明显提高，如果没有足够的业务支撑，很容易转向平衡成本，直接的办法就是少人或换人。」

这解释了为什么你去年聊的「十几年 Qt 经验一文不值」不是个例——AI 提了效，但企业第一反应不是让大家轻松，而是「可以少养人了」。

「单纯用自然语言表达，可以做出还不错的完整产品……但产品的质感和高度，最终是被个人的能力约束。」

这句比较清醒——门槛确实降低了，但能够定义问题、设计方案、判断路径的人依然稀缺。AI 把执行的门槛踩平了，但把判断的门槛抬高了。

---

和你一整天的对话对照

从下午聊到现在，今天的内容其实都在说同一件事：

| 时间 | 话题 | 指向同一个判断 |

|------|------|--------------|

| .NET 11 性能 | 运行时不改代码就白拿性能 | 工具在替你兜底 |

| 数据脱敏 | 不是增能力是划边界 | 人在定义「什么该保护」 |

| CLI vs MCP | 内循环 CLI 外循环 MCP | 人在选「什么场景用什么工具」 |

| Codex 记忆 | 两阶段 pipeline 抽取+合并 | 模型管记什么，代码管何时忘 |

| 测试人越来越累 | AI 太快了人必须兜底 | 人的价值从「做」变成了「判断」 |

| 三年红透半边天 | 效率提高业务没跟上 → 减人 | 判断力比执行力值钱 |

三年前 AI 刚火的时候，大家担心的是被替代。三年后 AI 真红了，才发现最累的不是「被替代」，而是站在 AI 的产出和最终结果之间，成了唯一的判断者和担责者。

文章最后一句话挺好：

「AI 可能也没想到，短短三年就红透半边天。」

但 AI 更不会想到的是——它红透半边天的这三年，真正被逼着成长的，不是它自己，是它背后那些既要用它、又要审它、还要替它背锅的人。

三公算账机器人开发测试需要「像真的」数据，合规要求「不是真的」数据。 [citation:7.14]

Thu, 17 Sep 2026 15:17:43 +0800

数据脱敏这件事，本质上回答一个矛盾：开发测试需要「像真的」数据，合规要求「不是真的」数据。 [citation:7.14]

下面按从顶层设计到底层算法的顺序完整拆开。

---

一、脱敏前必须做的事：分级分类

别一上来就配工具。先搞清楚库里哪些才是真正要保护的：

| 等级 | 举例 | 必须脱敏？ |

|------|------|:--------:|

| 高风险 | 身份证号、银行卡号、支付账号、生物识别、健康医疗数据 | 强制 |

| 中风险 | 姓名、手机号、家庭住址、精确 GPS 坐标 | 必须 |

| 低风险 | 性别、年龄区间、城市级别信息 | 按场景定 |

你不可能把所有字段都脱敏——成本扛不住，脱敏过度会导致数据完全失去分析价值。 [citation:7.15]

---

二、两种脱敏方式

🔹 静态脱敏（Static Data Masking）

原理：数据从生产环境导出时，做一次性批量改写——手机号变 1381234、姓名替换成随机姓氏、身份证重排——脱敏后的副本进入开发测试库。原始数据不出生产环境。 [citation:7.14]

生产库 ──→ 脱敏引擎（替换/遮蔽/泛化）──→ 测试库（"假"数据）

原始数据不出生产环境 ✅

| 优点 | 缺点 |

|------|------|

| 一次性处理，之后随便用不违规 | 数据已固化，不能反映最新生产状态 |

| 保留格式、长度、分布特征 | 规则变更需重新导出 |

| 工具或脚本即可实现，成本最低 | 不适合实时查询场景 |

典型场景：测试环境搭建、数据分析师取数、外包开发、培训演示。 [citation:7.3]

🔹 动态脱敏（Dynamic Data Masking）

原理：在查询返回时实时拦截改写。数据库里存的是真实数据，但根据用户身份决定返回脱敏还是原始值。原始数据不出生产库。 [citation:7.7][citation:7.11]

用户查询 ──→ 数据库 ──→ 脱敏拦截层（解析SQL，改写结果）──→ 脱敏后数据

↑ 根据用户角色判断脱敏策略

| 优点 | 缺点 |

|------|------|

| 实时生效，数据始终最新 | 每次查询都有脱敏计算开销 |

| 同一张表对不同角色显示不同内容 | 实现复杂度高（SQL解析、协议代理） |

| 无需维护多份数据副本 | 高并发场景可能成为瓶颈 |

典型场景：生产环境查询权限控制、客服系统掩码显示、API 输出脱敏。 [citation:7.4]

两者对比

| 维度 | 静态脱敏 | 动态脱敏 |

|------|:--------:|:--------:|

| 数据存储 | 副本存储的是脱敏后数据 | 原库存真实数据 |

| 生效时机 | 批量一次性 | 每次查询实时 |

| 数据新鲜度 | 脱敏时点的快照 | 始终最新 |

| 实现复杂度 | 低（脚本/ETL） | 高（SQL代理/拦截） |

| 生产数据外泄风险 | 副本中已是假数据，风险低 | 拦截层必须绝对安全 |

| 典型部署位置 | 导出管道中 | DB 网关 / 应用中间件 / SQL Server 内置 |

---

三、六种脱敏算法

| 算法 | 做法 | 输入 | 输出 | 适用 |

|------|------|------|------|------|

| 替换 | 用假数据置换真数据 | 张三 | 李四 | 姓名、地址 |

| 遮蔽 | 部分遮挡 | 13812345678 | 1385678 | 手机号、银行卡 |

| 泛化 | 降低精度 | 25岁 | 20-30岁 | 年龄、位置 |

| 加密 | AES 加密存储，授权才能解密 | 1101011990... | A7F2E9... | 需反向还原的场景 |

确定性脱敏是个特殊变体——同一个真实值无论出现多少次，脱敏后的值都一样。这对跨表 JOIN 至关重要：如果张三在订单表和客户表里分别被替换成不同的随机名，两张表就关联不上了。 [citation:7.9][citation:7.10]

---

四、一条典型的脱敏流程

敏感数据发现脱敏执行

┌────────────────────┐ ┌──────────────────┐

│ 内置规则扫描 │ │ 替换：姓名→随机名 │

│ 正则匹配手机号/身份证│ │ 遮蔽：手机号→掩码 │

│ ML模型识别非结构文本│ │ 泛化：年龄→区间 │

│ 人工复核+分类标注 │ │ 加密：身份证→AES │

└────────┬───────────┘ └────────┬─────────┘

│ │

▼ ▼

数据资产清单脱敏规则映射（字段→算法）

│ │

└───────────────┬───────────────┘

▼

任务管理 + 水印注入

│

▼

脱敏后数据输出

（保留格式+统计分布特征）

关键：脱敏不是一次性的。数据字段增加、脱敏规则更新、合规要求变化，都需要重新执行。 [citation:7.12]

---

五、各数据库/平台的内置支持

| 平台 | 方式 | 说明 |

|------|------|------|

| SQL Server | 动态脱敏 DDM | ALTER TABLE ... MASKED WITH (FUNCTION = 'partial(2,"",2)')，对非授权用户直接返回掩码值 [citation:7.7] |

| openGauss | 动态脱敏 | 定制脱敏策略，按用户身份动态拦截查询结果 [citation:7.13] |

| 阿里云 DataWorks | 静态+动态 | 配置脱敏规则和策略，在数据开发环节实施 [citation:7.12] |

| 华为云 DSC | 静态+动态 | 内置 Hash、加密、字符掩盖、关键字替换、取整、仿真等算法 [citation:7.10] |

| 应用层实现 | 中间件拦截 | 解析 SQL → 改写结果集，与数据库无关，但性能损耗最大 |

---

六、常见坑

脱敏后 JOIN 断裂——确定性脱敏没开，同一个客户在两张表里变成了不同的随机名 → 无法关联分析

脱敏过度——把性别、城市这种低风险字段也脱了，数据分析师拿到数据什么结论都跑不出来

逆向推断——生日+邮编+性别这三个字段单独看是中低风险，组合起来可以唯一锁定一个人（美国 87% 人口可被这三维唯一标识）

只脱敏数据库，不脱敏日志——应用的访问日志里明文打了手机号，数据库脱了，日志没脱，泄露就是从日志走的

动态脱敏的 SQL 盲区——SELECT * FROM ... WHERE phone = '13812345678'，WHERE 条件里的明文不会被脱敏拦截层改写，SQL 日志里依然可见

---

📌 和你之前话题的联系

你聊 Qt C++ 里标准外设库替你做「时钟→GPIO」的完整调用链——数据脱敏本质上是数据管线的「标准外设库」：

| 标准外设库 | 数据脱敏 |

|-----------|---------|

| 封装硬件寄存器操作 | 封装敏感数据操作 |

| 保证时序正确（先开时钟再配GPIO） | 保证合规正确（先识别再脱敏再输出） |

| 开发者无需翻手册 | 数据使用者无需接触明文 |

| 可用寄存器直写做性能优化 | 可用动态脱敏做实时查询 |

两者的设计哲学一模一样：不是增能力，而是划边界——让数据的「使用权限」和「实际值」在物理上解耦。

微信三公机器人 FastAPI 使用 Session 认证

Wed, 16 Sep 2026 11:54:24 +0800

FastAPI 本身不内置 session 机制（它推崇 OAuth2/JWT），但实际项目中 session 认证仍然是最简单、最常用的方案之一——尤其适合内部系统、管理后台、SSO 对接。下面从原理到完整实现讲透。

---

一、Session 认证 vs JWT 认证

| 维度 | Session（服务端存储） | JWT（客户端存储） |

|------|----------------------|-------------------|

| 状态 | 有状态，服务端保存会话 | 无状态，令牌自包含 |

| 存储 | 服务端内存/Redis/数据库 | 客户端 Cookie/localStorage |

| 注销 | 删服务端记录即生效 | 需黑名单或等令牌过期 |

| 扩展性 | 需共享 session 存储（Redis） | 天然支持多实例 |

| 安全性 | Cookie HttpOnly，XSS 防护好 | localStorage 易被 XSS 窃取 |

| 适用场景 | 内部系统、管理后台、传统 Web | API 服务、微服务、移动端 |

| 复杂度 | 低 | 中 |

---

二、最小可用实现（内存 Session）

2.1 安装依赖

pip install fastapi uvicorn itsdangerous python-multipart

| 包 | 用途 |

|---|------|

| fastapi | Web 框架 |

| uvicorn | ASGI 服务器 |

| itsdangerous | 签名 Cookie（防篡改） |

| python-multipart | 解析表单数据 |

2.2 完整代码

from fastapi import FastAPI, Request, Form, Depends, HTTPException

from fastapi.responses import HTMLResponse, RedirectResponse

from itsdangerous import URLSafeTimedSerializer

from datetime import timedelta

import secrets

app = FastAPI()

── 配置 ──

SECRETKEY = "your-secret-key-change-in-production" # 生产环境用 secrets.tokenhex(32)

SESSIONCOOKIENAME = "session_id"

SESSIONMAXAGE = 86400 # 24 小时（秒）

── Session 存储（内存版，生产环境换 Redis）──

sessionstore: dict = {} # { sessionid: {"user_id": 1, "username": "admin", "role": "admin"} }

── Cookie 签名器 ──

serializer = URLSafeTimedSerializer(SECRET_KEY, salt="session")

def create_session(data: dict) -> str:

"""创建 session，返回签名后的 session_id"""

sessionid = secrets.tokenhex(32)

sessionstore[sessionid] = data

return session_id

def getsessionid(request: Request) -> str | None:

"""从 Cookie 中提取并验证 session_id"""

signed = request.cookies.get(SESSIONCOOKIENAME)

if not signed:

return None

try:

# 验证签名 + 过期时间

sessionid = serializer.loads(signed, maxage=SESSIONMAXAGE)

return session_id

except Exception:

return None

def getcurrentuser(request: Request):

"""依赖项：获取当前登录用户，未登录则 401"""

sessionid = getsession_id(request)

if not sessionid or sessionid not in session_store:

raise HTTPException(status_code=401, detail="未登录，请先登录")

return sessionstore[sessionid]

def require_role(role: str):

"""依赖项：要求特定角色"""

def checker(user = Depends(getcurrentuser)):

if user.get("role") != role:

raise HTTPException(status_code=403, detail=f"需要 {role} 权限")

return user

return checker

── 模拟用户数据库 ──

USERS = {

"admin": {"id": 1, "username": "admin", "password": "admin123", "role": "admin"},

"user": {"id": 2, "username": "user", "password": "user123", "role": "user"},

}

── 登录页面 ──

@app.get("/login", response_class=HTMLResponse)

async def login_page():

return """

</form>

"""

── 登录处理 ──

@app.post("/login")

async def login(request: Request, username: str = Form(...), password: str = Form(...)):

user = USERS.get(username)

if not user or user["password"] != password:

raise HTTPException(status_code=401, detail="用户名或密码错误")

# 创建 session

sessionid = createsession({

"user_id": user["id"],

"username": user["username"],

"role": user["role"],

})

# 签名后写入 Cookie

signed = serializer.dumps(session_id)

response = RedirectResponse(url="/dashboard", status_code=303)

response.set_cookie(

key=SESSIONCOOKIENAME,

value=signed,

maxage=SESSIONMAX_AGE,

httponly=True, # JS 不可读，防 XSS

secure=False, # 生产环境 True（仅 HTTPS）

samesite="lax", # 防 CSRF

)

return response

── 登出 ──

@app.post("/logout")

async def logout(request: Request):

sessionid = getsession_id(request)

if sessionid and sessionid in session_store:

del sessionstore[sessionid] # 服务端删除，立即失效

response = RedirectResponse(url="/login", status_code=303)

response.deletecookie(SESSIONCOOKIE_NAME)

return response

── 受保护页面 ──

@app.get("/dashboard", response_class=HTMLResponse)

async def dashboard(user = Depends(getcurrentuser)):

return f"""

<h2>欢迎，{user['username']}！</h2>

</form>

"""

── 仅管理员可访问 ──

@app.get("/admin")

async def adminpage(user = Depends(requirerole("admin"))):

return {"message": f"管理员 {user['username']} 访问了管理后台"}

── 公开接口 ──

@app.get("/")

async def index():

return {"message": "首页，无需登录"}

2.3 运行

uvicorn main:app --reload

打开 http://localhost:8000/login

账号 admin / admin123 或 user / user123

---

三、生产级实现（Redis Session）

内存版重启即丢失、多进程不共享。生产环境用 Redis：

pip install redis aioredis

import redis

import json

import secrets

from datetime import timedelta

── Redis 连接 ──

redisclient = redis.Redis(host="localhost", port=6379, db=0, decoderesponses=True)

SESSION_PREFIX = "session:"

SESSION_TTL = 86400 # 24 小时

class SessionManager:

"""Redis-backed Session 管理"""

def create(self, data: dict) -> str:

sessionid = secrets.tokenhex(32)

redis_client.setex(

f"{SESSIONPREFIX}{sessionid}",

SESSION_TTL,

json.dumps(data),

)

return session_id

def get(self, session_id: str) -> dict | None:

data = redisclient.get(f"{SESSIONPREFIX}{session_id}")

if data:

# 续期（滑动过期）

redisclient.expire(f"{SESSIONPREFIX}{sessionid}", SESSIONTTL)

return json.loads(data)

return None

def delete(self, session_id: str):

redisclient.delete(f"{SESSIONPREFIX}{session_id}")

def deletebyuser(self, user_id: int):

"""踢掉某用户所有 session（改密码后调用）"""

for key in redisclient.scaniter(f"{SESSION_PREFIX}*"):

data = json.loads(redis_client.get(key))

if data and data.get("userid") == userid:

redis_client.delete(key)

session_manager = SessionManager()

替换依赖项：

def getcurrentuser(request: Request):

sessionid = getsession_id(request)

if not session_id:

raise HTTPException(status_code=401, detail="未登录")

userdata = sessionmanager.get(session_id)

if not user_data:

raise HTTPException(status_code=401, detail="会话已过期，请重新登录")

return user_data

---

四、使用 Starlette SessionMiddleware（更简洁）

FastAPI 基于 Starlette，可以直接用其内置的 SessionMiddleware（基于 itsdangerous 签名 Cookie）：

from fastapi import FastAPI, Request, Form, Depends, HTTPException

from fastapi.responses import HTMLResponse, RedirectResponse

from starlette.middleware.sessions import SessionMiddleware

from datetime import timedelta

app = FastAPI()

添加 Session 中间件

app.add_middleware(

SessionMiddleware,

secret_key="your-secret-key-change-in-production",

sessioncookie="sessionid",

max_age=86400, # 24 小时

httponly=True,

secure=False, # 生产环境 True

samesite="lax",

)

def getcurrentuser(request: Request):

"""从 Starlette session 中获取用户"""

user = request.session.get("user")

if not user:

raise HTTPException(status_code=401, detail="未登录")

return user

def require_role(role: str):

def checker(user = Depends(getcurrentuser)):

if user.get("role") != role:

raise HTTPException(status_code=403, detail=f"需要 {role} 权限")

return user

return checker

USERS = {

"admin": {"id": 1, "username": "admin", "password": "admin123", "role": "admin"},

"user": {"id": 2, "username": "user", "password": "user123", "role": "user"},

}

@app.get("/login", response_class=HTMLResponse)

async def login_page():

return """

</form>

"""

@app.post("/login")

async def login(request: Request, username: str = Form(...), password: str = Form(...)):

user = USERS.get(username)

if not user or user["password"] != password:

raise HTTPException(status_code=401, detail="用户名或密码错误")

# 直接写入 session（中间件自动签名+设Cookie）

request.session["user"] = {

"user_id": user["id"],

"username": user["username"],

"role": user["role"],

}

return RedirectResponse(url="/dashboard", status_code=303)

@app.post("/logout")

async def logout(request: Request):

request.session.clear() # 清除 session

return RedirectResponse(url="/login", status_code=303)

@app.get("/dashboard", response_class=HTMLResponse)

async def dashboard(user = Depends(getcurrentuser)):

return f"""

<h2>欢迎，{user['username']}！</h2>

</form>

"""

@app.get("/admin")

async def admin(user = Depends(require_role("admin"))):

return {"message": f"管理员 {user['username']} 访问了管理后台"}

SessionMiddleware 的原理：session 数据存在签名 Cookie 里（不在服务端存储），每次请求自动解签还原到 request.session。优点是零服务端存储、多实例天然兼容；缺点是 Cookie 大小限制 4KB，不能存大量数据。

---

五、三种方案对比

|------|-----------------|---------------|-------------------|

| 多实例共享 | ❌ | ✅ | ✅（无需共享） |

| 重启保持 | ❌ | ✅ | ✅ |

| Cookie 大小限制 | 无 | 无 | 4KB |

| 注销即时生效 | ✅ | ✅ | ❌（需等 Cookie 过期） |

| 踢人/批量下线 | ✅ | ✅ | ❌ |

| 复杂度 | 低 | 中 | 最低 |

---

六、安全加固清单

| 措施 | 说明 | 代码 |

|------|------|------|

| HttpOnly Cookie | JS 不可读，防 XSS 窃取 | httponly=True |

| Secure Cookie | 仅 HTTPS 传输 | secure=True（生产环境） |

| SameSite=Lax | 防 CSRF | samesite="lax" |

| 签名防篡改 | itsdangerous 签名 | URLSafeTimedSerializer |

| CSRF Token | 表单提交加随机 token | 见下方 |

| 密码哈希 | 不存明文密码 | passlib / bcrypt |

| 登录限流 | 防暴力破解 | slowapi |

| Session 续期 | 滑动过期 | 每次访问刷新 TTL |

| 改密码踢人 | 改密码后清除旧 session | sessionmanager.deleteby_user() |

密码哈希

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def verify_password(plain: str, hashed: str) -> bool:

return pwd_context.verify(plain, hashed)

def hash_password(password: str) -> str:

return pwd_context.hash(password)

注册时：hash_password("admin123") → 存数据库

登录时：verifypassword(inputpassword, dbhashedpassword)

CSRF 防护

import secrets

@app.get("/form")

async def form_page(request: Request):

csrftoken = secrets.tokenhex(16)

request.session["csrftoken"] = csrftoken

return HTMLResponse(f"""

</form>

""")

@app.post("/submit")

async def submit(request: Request, data: str = Form(...), csrf_token: str = Form(...)):

if csrftoken != request.session.get("csrftoken"):

raise HTTPException(status_code=403, detail="CSRF token 验证失败")

return {"data": data}

---

七、完整路由保护模式

from fastapi import APIRouter

创建受保护的路由器

protected_router = APIRouter(

prefix="/api",

dependencies=[Depends(getcurrentuser)], # 所有路由都需要登录

)

admin_router = APIRouter(

prefix="/admin",

dependencies=[Depends(require_role("admin")], # 所有路由都需要 admin

)

@protected_router.get("/profile")

async def profile(user = Depends(getcurrentuser)):

return {"username": user["username"]}

@protected_router.get("/orders")

async def orders(user = Depends(getcurrentuser)):

return {"orders": [], "user": user["username"]}

@adminrouter.delete("/users/{userid}")

async def deleteuser(userid: int, admin = Depends(require_role("admin"))):

return {"message": f"管理员 {admin['username']} 删除了用户 {user_id}"}

注册路由器

app.includerouter(protectedrouter)

app.includerouter(adminrouter)

---

八、方案选择决策树

需要 Session 认证？

│

├── 小型应用 / 无状态部署 / 不需要踢人

│ └── SessionMiddleware（最简，Cookie 自包含）

│

├── 中大型应用 / 需要踢人 / 需要滑动过期 / 多实例

│ └── Redis Session（生产推荐）

│

└── 开发测试 / 单实例

└── 内存 Session（最快上手）

核心就一条链：登录验证 → 创建 session → 签名写入 HttpOnly Cookie → 后续请求自动带 Cookie → 服务端验证 session → Depends(getcurrentuser) 注入用户信息。生产环境用 Redis 存储 + HttpOnly + Secure + SameSite + CSRF Token + 密码哈希，安全闭环就齐了。

三公机器人 | 三公九门 | 三公人头

三公算账机器人 核心矛盾：OpenMP 的 fork/join 模型不适合细粒度并行

微信三公机器人 核心矛盾："权重不止是三元数"

QQ三公机器人 无锁编程在实际项目中好用吗

三公自动算账 DTO、VO、PO 到底要不要拆？一篇讲透 Java 实体分层的底层逻辑

三公算账机器人 Fable 5.1 操刀，内存腰斩，外星科技——SimdPaddleOCR 1.4 发布！

微信三公机器人 来展开"主从复制扩展"这个系列第一部分的完整框架

QQ三公机器人 Overlap Scheduler 在做什么

三公自动算账 AI 三年红透半边天，但人的处境变了，而且变复杂了

三公算账机器人 开发测试需要「像真的」数据，合规要求「不是真的」数据。 [citation:7.14]

微信三公机器人 FastAPI 使用 Session 认证

三公算账机器人核心矛盾：OpenMP 的 fork/join 模型不适合细粒度并行

微信三公机器人核心矛盾："权重不止是三元数"

QQ三公机器人无锁编程在实际项目中好用吗

微信三公机器人来展开"主从复制扩展"这个系列第一部分的完整框架

三公算账机器人开发测试需要「像真的」数据，合规要求「不是真的」数据。 [citation:7.14]