在 AI 编程助手几乎成为开发者「标配」的 2026 年，各大厂商的 Coding Plan（编程套餐）已成为新的战场。不同于单纯的 API 按量付费，Coding Plan 以固定月费换取高频、低延迟、不限峰值的模型调用权限，正成为日常写代码的主力方案。

本文基于笔者对 Moonshot Kimi 的实际使用体验（含真实 Token 消耗数据推算），并结合国内六大主流厂商的最新套餐，做一份全景式对比，供开发者选型参考。

一、Kimi Coding Plan：真实额度推算

1.1 套餐档位

Moonshot Kimi 目前提供三档 Coding Plan（均以 7 天为周期刷新额度，未用完不累积）：

此外，Kimi 在 2026 年初推出了限时 3 倍额度扩容活动，活动期间所有套餐的编程额度自动翻 3 倍，这让中低档位用户的实际可用量大幅提升。

1.2 从真实账单反推额度

笔者订阅的是 Kimi Coding Plan，当前周期（7 天滚动）已运行约 6.3 天，距离下次重置还剩 17 小时。通过解析本地 ~/.kimi/sessions/*/wire.jsonl 的 StatusUpdate 记录，得到以下真实消耗：

后台显示本周已消耗 62% 的额度，由此反推：

周期额度 ≈ 1.63 亿 ÷ 0.62 ≈ 2.64 亿 Tokens
剩余额度 ≈ 1.00 亿 Tokens（38%）

也就是说，在限时 3 倍扩容的加持下，笔者所在的这档套餐，单周期（7 天）可用额度约为 2.6 亿 Tokens。若按自然月折算，月可用 Token 量轻松突破 10 亿。

关键发现：Kimi 的 Token 消耗中，input_cache_read 占了绝对大头（约 95%）。这是 Moonshot 的上下文缓存机制在起作用——重复读取已缓存的上下文会被计入 Token，但实际计费时通常有折扣。因此，2.6 亿的「名义 Token」与实际等效 API Token 并不能 1:1 划等号，实际等效调用量可能更高。

二、国内主流 Coding Plan 横向对比

下面将 Kimi 与阿里云百炼、火山方舟（字节）、智谱 GLM、MiniMax、DeepSeek 等国内主流方案进行横向对比。

2.1 核心参数一览

2.2 进阶套餐对比

三、深度解析：各家优劣势

3.1 Kimi：长上下文与原生多模态的「重炮手」

优势：

• 模型性能强：Kimi K2.5 是国内参数规模最大的旗舰模型之一（1T 参数），支持 256K 长上下文和原生多模态（截图即可 Vibe Coding）。
• Token 额度充裕：在 3 倍扩容活动下，入门档即可获得单周数亿级的 Token 配额，对于大型代码库分析、长文档处理非常友好。
• Agent 能力突出：Allegretto 档支持 Agent 集群，适合复杂多步骤开发任务。

劣势：

• 工具生态封闭：仅官方支持 Kimi CLI、VSCode 插件、Claude Code、Roo Code 等少数工具，非指定工具使用有封号风险。
• 仅限个人：明确禁止企业场景使用。
• 缓存机制不透明：大量 Token 消耗在 input_cache_read 上，实际可用次数与名义 Token 数存在认知差，新手容易「看不懂账单」。

3.2 阿里云百炼：「稳」字当头的多模型超市

优势：

• 模型选择最丰富：一次订阅即可调用 Qwen、GLM、Kimi、MiniMax 等多家模型，相当于「模型超市」。
• 阿里云基础设施：稳定性在国内第一梯队，适合对 SLA 有要求的商业项目。
• 首月价格极低：Lite 首月 ¥7.9，几乎等于白送。

劣势：

• Lite 已停售：2026 年 3 月 20 日起停止新购，4 月 13 日起停止续费，入门门槛被抬高到 Pro（¥200/月）。
• 不支持子账号：仅主账号可用，团队协作不便。

3.3 火山方舟（字节）：「多而全」的 Auto 调度派

优势：

• 模型数量最多：不仅支持字节自研的豆包 Seed Code，还聚合了 DeepSeek、GLM、Kimi 等第三方模型，支持 Auto 模式自动匹配最优模型。
• 工具适配最广：支持 Claude Code、Cursor、Cline、ArkClaw 等 7 款以上工具，配置简单。
• 等效 Token 量大：Pro 档每月可用额度折算后高达「大几亿至数十亿 Token」。

劣势：

• 高峰期超售：用户反馈高峰期响应缓慢，频繁出现 400/429 错误。
• 退款条款苛刻：订阅前需仔细阅读退订政策。

3.4 智谱 GLM：工具链最完善的「极客之选」

优势：

• 工具适配无敌：支持 20+ 款编程工具（Claude Code、Cline、CodeGeeX 等），并提供免费 MCP 工具链。
• 纯自研模型：GLM-5（744B 参数，MoE 架构）在开源社区口碑极佳，代码能力国内第一梯队。

劣势：

• 涨价后性价比下滑：2026 年 2 月 Lite 从 ¥40 涨至 ¥49，且取消首购优惠，入门档每周仅 400 次 Prompt，重度用户容易触顶。
• 额度抵扣复杂：GLM-5 高峰期按 3 倍、非高峰按 2 倍抵扣，计费心智成本高。

3.5 MiniMax：低价高频的「轻量快刀」

优势：

• 入门价最低：Starter 仅 ¥29/月，首月 ¥9.9。
• 无每周限额：仅有每 5 小时 40 次的短周期限制，适合连续高强度使用（如通宵赶项目）。
• 响应速度快：极速版可达 100+ TPS。

劣势：

• 模型规模小：M2.5 仅 10B 参数级别，适合轻量脚本任务，面对大型代码库或复杂推理时能力有限。

3.6 DeepSeek：不按套路出牌的「价格屠夫」

优势：

• 无订阅费：纯 API 按量付费，无月费门槛。
• 价格全球最低：V3.2 输入仅 $0.27~0.30 / 百万 Token，缓存命中低至 $0.028 / 百万 Token，比 GPT-5 便宜 80% 以上。
• 新用户免费送 500 万 Token（30 天内有效）。

劣势：

• 无专属 Coding Plan：没有固定月费的「无限额度」套餐，高频使用者难以预估月度成本。
• 稳定性波动：高峰期偶发延迟，且没有订阅用户的优先级保障。

四、选型建议：对号入座

五、结论

从笔者对 Kimi Coding Plan 的实际使用数据来看，在 3 倍扩容活动的加持下，Kimi 入门档的单周 Token 额度（约 2.6 亿 Tokens）已经处于国内第一梯队水平，与火山方舟 Pro、阿里云百炼 Pro 的「大几亿至数十亿」月额度处于同一量级。考虑到 Kimi K2.5 的模型规模（1T 参数）和长上下文能力（256K），其「单位 Token 能买到的模型性能」具有很强竞争力。

然而，Kimi 的短板同样明显：工具生态封闭、仅限个人使用、缓存机制不透明。如果你是习惯在多种 IDE 和 Agent 框架间切换的开发者，或者需要团队协作，火山方舟和阿里云百炼可能是更务实的中庸之选；如果你追求极致低价且能自己管理调用节奏，DeepSeek 依然是不可撼动的「价格屠夫」。

在 2026 年的 Coding Plan 战场，已经没有绝对的「最优解」，只有「最匹配你工作流」的选择。建议开发者优先利用各家的首月优惠或免费额度（Kimi 3 倍扩容、阿里云百炼 ¥7.9、DeepSeek 500 万免费 Token 等）进行实际体验，再决定长期订阅方案。

本文数据更新于 2026 年 4 月 22 日。Coding Plan 价格和活动变动频繁，请以各厂商官网最新信息为准。

记录从开箱到开箱即用的完整折腾路径，包括内核兼容性修复和开机自动配置。

目录

• 背景
• 问题一：驱动编译失败
• 问题二：每次开机都要手动加载驱动
• 问题三：为什么要"拔掉再插上"
• 完整解决方案
• 总结

背景

硬件：UGREEN AX900 USB WiFi 6 网卡
芯片：AICSemi AIC8800DC
系统：Ubuntu 24.04 LTS
内核：6.17.0-20-generic

刚装完系统，插入网卡，没有任何反应。

$ lsusb | grep -i aic
# 空，什么都没有

$ ip link
# 只有 lo 和有线网卡，没有无线网卡

AIC8800 官方驱动只支持到内核 3.10+，在 Linux 6.x 上编译直接报错。于是开始了折腾之路。

问题一：驱动编译失败

现象

从绿联官网或 AICSemi 下载的驱动源码，直接 make 报错：

$ make
...
error: implicit declaration of function 'del_timer'
error: too few arguments to function 'cfg80211_rx_spurious_frame'
error: initialization of 'int (*)(struct wiphy *, int, u32)' from incompatible pointer type
...

原因分析

Linux 6.x 内核有几处 API 变更：

修复方案

1. 修复 del_timer API

在 rwnx_main.c、rwnx_rx.c、aicwf_tcp_ack.c 中添加：

#include <linux/version.h>
#include <linux/timer.h>

#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0)
#define del_timer(timer) timer_delete(timer)
#define del_timer_sync(timer) timer_delete_sync(timer)
#endif

2. 修复 cfg80211 API

在 rwnx_main.c 中修改两个函数签名：

// set_wiphy_params 增加 radio_idx 参数
static int rwnx_cfg80211_set_wiphy_params(struct wiphy *wiphy,
#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0)
                                          int radio_idx,
#endif
                                          u32 changed)

// set_tx_power 增加 radio_idx 参数
static int rwnx_cfg80211_set_tx_power(struct wiphy *wiphy,
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
    struct wireless_dev *wdev,
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0)
    int radio_idx,
#endif
    enum nl80211_tx_power_setting type, int mbm)

3. 修复 wakeup_source API

在 rwnx_wakelock.c 中：

struct wakeup_source *rwnx_wakeup_init(const char *name)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0)
    return wakeup_source_register(NULL, name);
#else
    struct wakeup_source *ws;
    ws = wakeup_source_create(name);
    wakeup_source_add(ws);
    return ws;
#endif
}

4. 修复 sprintf 源目标重叠

在 aicwf_compat_8800d80.c 等文件中：

// 错误的写法（GCC 会警告）
sprintf(aic_fw_path, "%s/%s", aic_fw_path, "aic8800DC");

// 正确的写法
{
    char tmp_path[200];
    strncpy(tmp_path, aic_fw_path, sizeof(tmp_path) - 1);
    tmp_path[sizeof(tmp_path) - 1] = '\0';
    snprintf(aic_fw_path, sizeof(aic_fw_path), "%s/%s", tmp_path, "aic8800DC");
}

5. 修复 from_timer 宏

在需要使用的文件中添加：

#ifndef from_timer
#define from_timer(var, callback_timer, timer_fieldname) \
    container_of(callback_timer, typeof(*var), timer_fieldname)
#endif

编译安装

cd aic8800_linux_driver/drivers/aic8800
make clean
make
sudo make install

成功后会生成两个 .ko 文件：

• aic_load_fw/aic_load_fw.ko - 固件加载器
• aic8800_fdrv/aic8800_fdrv.ko - WiFi 驱动

问题二：每次开机都要手动加载驱动

现象

每次重启后：

$ lsmod | grep aic
# 空的，驱动没加载

$ ip link
# 没有无线网卡

必须手动执行：

sudo modprobe cfg80211
sudo modprobe aic_load_fw
sudo modprobe aic8800_fdrv

原因

驱动没有配置为开机自动加载。

解决方案

方案 1：配置 modules-load.d（推荐）

echo -e "cfg80211\naic_load_fw\naic8800_fdrv" | sudo tee /etc/modules-load.d/aic8800.conf

方案 2：使用 systemd 服务

创建 /etc/systemd/system/aic8800-autoload.service：

[Unit]
Description=AIC8800 USB WiFi Driver
After=systemd-udev-settle.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/sbin/modprobe aic8800_fdrv

[Install]
WantedBy=multi-user.target

启用服务：

sudo systemctl daemon-reload
sudo systemctl enable aic8800-autoload.service

问题三：为什么要"拔掉再插上"

现象

按照网上教程，加载驱动后要：

1. lsmod | grep aic 确认驱动加载成功
2. 拔掉网卡
3. 重新插入网卡
4. 网卡才能工作

根本原因：USB 网卡的双模式设计

AIC8800 芯片的 USB WiFi 网卡采用双模式设计：

工作流程

插入网卡
    ↓
系统识别为 USB 存储设备 (a69c:5721)
    ↓
执行 eject /dev/aicudisk（弹出存储设备）
    ↓
网卡自动重新枚举为 WiFi 设备 (a69c:8800)
    ↓
驱动识别并初始化设备
    ↓
网卡正常工作

为什么必须先加载驱动再插网卡？

驱动加载顺序问题：

• 如果先插网卡，后加载驱动：

  • 网卡处于存储模式 (a69c:5721)
  • 驱动加载时寻找 WiFi 设备 (a69c:8800)，找不到
  • 驱动初始化失败或无法绑定设备

• 正确的顺序：

  1. 先加载驱动（注册 USB 设备监听）
  2. 插入网卡 → 触发 udev 规则 → 自动执行 eject 切换模式
  3. 网卡切换到 WiFi 模式 → 驱动识别并绑定

手动操作流程

# 1. 加载驱动（等待设备）
sudo modprobe cfg80211
sudo modprobe aic_load_fw
sudo modprobe aic8800_fdrv

# 2. 确认驱动已加载
lsmod | grep aic
# aic8800_fdrv          696320  0
# aic_load_fw            94208  1 aic8800_fdrv

# 3. 插入网卡（udev 自动处理模式切换）
# 或者手动切换：sudo eject /dev/aicudisk

# 4. 查看网卡
ip link
# wlan0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000

完整解决方案

一键配置开机自动加载

我已经创建了完整的自动配置脚本：

cd aic8800_linux_driver/tools/autostart
sudo ./setup-autostart.sh

这个脚本会自动完成：

1. 安装固件到 /lib/firmware/aic8800D80/
2. 配置 udev 规则：
   • 检测到存储模式 (a69c:5721) → 自动 eject 切换模式
   • 检测到 WiFi 模式 (a69c:8800) → 自动加载驱动
3. 配置模块开机加载：cfg80211、aic_load_fw、aic8800_fdrv
4. 创建 systemd 服务：处理开机时网卡已插入的情况

然后重启电脑，网卡就能自动识别了。

卸载自动配置

如果需要恢复手动操作：

sudo ./remove-autostart.sh

验证

检查网卡是否识别

$ lsusb | grep a69c
Bus 001 Device 007: ID a69c:8800 AICSemi AIC8800DC
# 注意 VID:PID 是 8800（WiFi 模式），不是 5721（存储模式）

检查驱动是否加载

$ lsmod | grep aic
aic8800_fdrv          696320  0
aic_load_fw            94208  1 aic8800_fdrv
cfg80211             1462272  3 b43,mac80211,aic8800_fdrv

检查网络接口

$ ip link
3: wlan0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP mode DORMANT group default qlen 1000
    link/ether xx:xx:xx:xx:xx:xx brd ff:ff:ff:ff:ff:ff

连接 WiFi

nmcli device wifi list
nmcli device wifi connect "SSID" password "password"

总结

最终效果：

• 开机自动识别网卡，无需手动操作
• 热插拔支持，随时插拔都能自动识别
• 适配 Linux 6.x 内核

参考

• 修复后的驱动源码：ugreen-ax900-6.x-kernel-fix-ver
• AICSemi 官方驱动（旧版）
• Linux 内核 API 变更文档

Ubuntu 24.04 + 内核 6.17.0

引言

Go 语言以其简洁的语法和强大的并发能力赢得了众多开发者的青睐。然而，Go 的魅力远不止于此——其内置的 runtime 系统才是支撑这一切的核心引擎。本文将深入 Go runtime 的源码，带你一探究竟，理解这个精巧系统如何高效地管理 goroutine、内存分配和垃圾回收。

1. Go Runtime 架构概览

Go runtime 是 Go 程序运行时的核心组件，它负责：

• Goroutine 调度
• 内存分配与垃圾回收
• 网络轮询
• 系统调用封装
• 栈管理

Runtime 的源码主要位于 src/runtime 目录下，其中最关键的几个文件包括：

• proc.go - 调度器实现
• mheap.go - 内存分配器
• mgc.go - 垃圾回收器
• netpoll.go - 网络轮询器

2. Goroutine 调度器：GMP 模型

2.1 什么是 GMP？

Go 的调度器采用 GMP 模型：

• G (Goroutine): 用户级轻量级线程
• M (Machine): 操作系统线程
• P (Processor): 逻辑处理器，包含 goroutine 队列

这种设计巧妙地解决了传统线程模型的性能瓶颈问题。

2.2 调度器工作原理

当一个 goroutine 被创建时，它会被放入某个 P 的本地队列中。M 线程会从关联的 P 中获取 goroutine 来执行。如果本地队列为空，M 会尝试从其他 P 的队列中"偷取"工作（work-stealing）。

关键数据结构：

// G 结构体（简化版）
type g struct {
    stack       stack          // goroutine 栈
    sched       gobuf          // 调度信息
    goid        int64          // goroutine ID
    status      uint32         // 状态
}

// M 结构体（简化版）
type m struct {
    g0          *g             // 用于调度的特殊 goroutine
    curg        *g             // 当前正在执行的 goroutine
    p           puintptr       // 关联的 P
}

// P 结构体（简化版）
type p struct {
    runq        [256]guintptr  // 本地运行队列
    runnext     guintptr       // 下一个要运行的 goroutine
}

2.3 调度时机

Go 调度器在以下时机进行调度：

• 系统调用：当 goroutine 进行系统调用时，M 可能会被阻塞，此时 runtime 会将 P 交给其他 M
• channel 操作：当 goroutine 在 channel 上阻塞时
• 网络 I/O：通过 netpoller 实现非阻塞 I/O
• 主动让出：通过 runtime.Gosched() 主动让出 CPU

3. 内存分配器

Go 的内存分配器借鉴了 TCMalloc 的设计思想，采用多级缓存策略来减少锁竞争。

3.1 内存分配层级

Go 的内存分配分为三个层级：

1. mcache: 每个 P 对应一个 mcache，用于小对象分配，无锁
2. mcentral: 全局中心缓存，按大小类组织，有锁但粒度较小
3. mheap: 全局堆，管理大块内存和虚拟地址空间

3.2 分配流程

当需要分配内存时：

1. 首先检查 mcache 中对应大小类的 span 是否有空闲对象
2. 如果没有，从 mcentral 获取一个 span
3. 如果 mcentral 也没有，从 mheap 分配新的 span

关键函数 mallocgc 的简化逻辑：

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    if size <= maxSmallSize {
        // 小对象分配
        if noscan && size < maxTinySize {
            // 微小对象分配（<16字节）
            return tinyAlloc(size, needzero)
        }
        // 小对象分配（16字节-32KB）
        return smallAlloc(size, needzero)
    }
    // 大对象分配（>32KB）
    return largeAlloc(size, needzero)
}

4. 垃圾回收器

Go 采用三色标记清除算法，实现了低延迟的并发垃圾回收。

4.1 三色标记法

• 白色: 未被访问的对象，垃圾回收后会被回收
• 灰色: 已被访问但其引用对象未被扫描的对象
• 黑色: 已被访问且其引用对象也已扫描的对象

4.2 GC 流程

Go 的 GC 分为四个阶段：

1. Sweep Termination: 清理上一轮 GC 的残留
2. Mark: 并发标记阶段，将可达对象标记为黑色
3. Mark Termination: 完成标记，重新扫描栈
4. Sweep: 并发清理白色对象

4.3 写屏障

为了保证并发标记的正确性，Go 使用了 Dijkstra 写屏障：

// 写屏障伪代码
func writePointer(slot *unsafe.Pointer, ptr unsafe.Pointer) {
    *slot = ptr
    if gcphase == _GCmark || gcphase == _GCmarktermination {
        gcWriteBarrier(ptr)
    }
}

写屏障确保在 GC 过程中，任何新建立的引用都会被正确标记。

5. 栈管理

Go 的 goroutine 栈是动态增长的，初始栈大小很小（2KB），根据需要自动扩展。

5.1 栈扩容

当函数调用需要更多栈空间时，runtime 会：

1. 分配更大的栈
2. 复制原有栈内容到新栈
3. 更新所有指向旧栈的指针

5.2 栈收缩

在 Go 1.3 之前，栈只会增长不会收缩。从 Go 1.4 开始，引入了栈收缩机制，当栈使用率低于 1/4 时会尝试收缩。

6. 网络轮询器

Go 的网络轮询器基于 epoll (Linux)、kqueue (macOS) 或 IOCP (Windows) 实现，将阻塞的网络 I/O 转换为非阻塞操作。

6.1 netpoller 工作原理

1. 当 goroutine 执行网络读写时，如果数据不可用，会将 goroutine 挂起
2. netpoller 监控文件描述符的可读/可写状态
3. 当文件描述符就绪时，netpoller 唤醒对应的 goroutine

6.2 关键数据结构

// pollDesc 结构体（简化版）
type pollDesc struct {
    link   *pollDesc     // 链表链接
    fd     uintptr       // 文件描述符
    rg     guintptr      // 读等待者
    wg     guintptr      // 写等待者
}

7. 性能优化技巧

基于对 runtime 的理解，我们可以写出更高效的 Go 代码：

7.1 减少内存分配

• 使用 sync.Pool 复用对象
• 预分配切片容量
• 避免不必要的字符串转换

7.2 优化 goroutine 使用

• 避免创建过多的 goroutine
• 使用 worker pool 模式限制并发数
• 及时关闭不再需要的 goroutine

7.3 GC 调优

• 通过 GOGC 环境变量调整 GC 频率
• 使用 debug.SetGCPercent() 动态调整
• 监控 GC 统计信息：runtime.ReadMemStats()

结论

Go runtime 是一个精巧而复杂的系统，它通过 GMP 调度模型、分层内存分配、并发垃圾回收等机制，为我们提供了高效的并发编程体验。理解 runtime 的工作原理不仅能满足我们的好奇心，更能帮助我们写出更高效、更可靠的 Go 代码。

正如 Rob Pike 所说："Concurrency is not parallelism, it's about composition." Go runtime 正是这种哲学的最佳体现——它让我们能够优雅地组合并发原语，构建复杂的并发系统。

参考资料

• Go 源码: https://github.com/golang/go/tree/master/src/runtime
• "Go 语言学习笔记" - 雨痕
• "Go 程序设计语言" - Alan A. A. Donovan & Brian W. Kernighan
• Go Blog: https://blog.golang.org/

搞了一下分享出来

打开终端，输入如下指令

vi ~/.oh-my-zsh/themes/robbyrussell.zsh-theme

进入后按99dd，然后按i键后，粘贴如下内容

PROMPT="%(?:%{$fg_bold[green]%}%1{➜%} :%{$fg_bold[red]%}%1{➜%} ) %{$fg[cyan]%}%~%{$reset_color%}"
PROMPT+=' $(git_prompt_info)'

ZSH_THEME_GIT_PROMPT_PREFIX="%{$fg_bold[blue]%}git:(%{$fg[red]%}"
ZSH_THEME_GIT_PROMPT_SUFFIX="%{$reset_color%} "
ZSH_THEME_GIT_PROMPT_DIRTY="%{$fg[blue]%}) %{$fg[yellow]%}%1{✗%}"
ZSH_THEME_GIT_PROMPT_CLEAN="%{$fg[blue]%})"

最近遇到一个业务上的问题，用户进行一个操作，会同时生成两个kafka消息

在一个消费者消费消息的时候依赖另一个消费者生产的数据

被依赖方执行的速度比依赖方的慢，所以希望延迟一点消费这条数据

处理方法

kafka生产消息的时候可以加入一个delay参数，用于控制消息的延迟消费

但是这里的问题是生产者面对非常多的消费者，加入这个参数风险不可控

所以决定在希望延迟消费的消费者这里加入一个时间轮，用于实现延迟消费的功能

所以有了这篇文章

时间轮代码

package timewheel

import (
    "container/list"
    "fmt"
    "sync"
    "time"
)

type Timer struct {
    expiration time.Time
    task       func()
}

type TimeWheel struct {
    ticker      *time.Ticker  // 定时器
    slots       []*list.List  // 时间槽
    currentSlot int           // 当前时间槽
    slotCount   int           // 时间槽数量
    duration    time.Duration // 时间槽间隔
    lock        sync.Mutex    // 锁
}

// NewTimeWheel 创建时间轮
func NewTimeWheel(slotCount int, duration time.Duration) *TimeWheel {
    slots := make([]*list.List, slotCount)
    for i := range slots {
        slots[i] = list.New()
    }
    return &TimeWheel{
        ticker:      time.NewTicker(duration),
        slots:       slots,
        slotCount:   slotCount,
        duration:    duration,
        currentSlot: 0,
    }
}

// AddTask 添加一个定时任务到时间轮
func (tw *TimeWheel) AddTask(delay time.Duration, task func()) {
    tw.lock.Lock()
    defer tw.lock.Unlock()

    expiration := time.Now().Add(delay)

    // 计算定时任务在时间轮中的到期时间, 添加到对应的时间槽
    ticks := int(delay / tw.duration)
    slotIndex := (tw.currentSlot + ticks) % tw.slotCount

    timer := &Timer{expiration: expiration, task: task}
    tw.slots[slotIndex].PushBack(timer)
}

// Start 启动时间轮
func (tw *TimeWheel) Start() {
    go func() {
        defer func() {
            if err := recover(); err != nil {
                fmt.Println("timeWheel panic: ", err)
            }
        }()
        for range tw.ticker.C {
            tw.tickHandler()
        }
    }()
}

// Stop 停止时间轮
func (tw *TimeWheel) Stop() {
    tw.ticker.Stop()
}

func (tw *TimeWheel) tickHandler() {
    tw.lock.Lock()
    defer tw.lock.Unlock()

    slot := tw.slots[tw.currentSlot]
    tw.currentSlot = (tw.currentSlot + 1) % tw.slotCount

    for e := slot.Front(); e != nil; {
        next := e.Next()
        timer := e.Value.(*Timer)
        if timer.expiration.Before(time.Now()) || timer.expiration.Equal(time.Now()) {
            go timer.task()
            slot.Remove(e)
        }
        e = next
    }
}

{
    "registry-mirrors": [
        "https://docker.1panel.live",
        "https://hub.rat.dev"
    ]
}

https://nothamor-1251700120.cos.ap-shanghai.myqcloud.com/Go%E9%9D%A2%E8%AF%95%E9%A2%98.pdf

Golang大厂面经

https://nothamor-1251700120.cos.ap-shanghai.myqcloud.com/Go%20%E5%A4%A7%E5%8E%82%E9%9D%A2%E7%BB%8F.zip

SSE接口代码, 发送信息修改sendEvents内代码即可：

func ChatStreamSSE(ctx context.Context, c *gin.Context, req vo.ChatCompletionRequest) {
event := Event{
    ConversationId: uuid.New().String(),
    IsFinish:       false,
    IsReasoning:    false,
}

stream, err := openai.NewChatCompletionStream(ctx, req)
if err != nil {
    logger.Ex(ctx, tag, "NewChatCompletionStream:%+v", err)
    event.Content = fmt.Sprintf("new chat completion stream failed. err:[%+v]", err)
    event.IsFinish = true
    c.SSEvent("data", event)
    c.Writer.Flush()
    return
}
defer stream.Close()

for {
    streamData, streamErr := stream.Recv()
    if streamErr != nil && !errors.Is(streamErr, io.EOF) && streamErr.Error() != "EOF" {
        logger.Ex(ctx, tag, "stream data error: %v", streamErr)
        event.Content = fmt.Sprintf("stream data error: %v", streamErr)
        event.IsFinish = true
        c.SSEvent("data", event)
        c.Writer.Flush()
    }
    c.SSEvent("data", event)
    c.Writer.Flush()
}

return
}

因为写过了很多爬虫项目，临近科目四考试，在驾考宝典刷题的时候就在想能不能把这些题目全都爬取下来，百度搜了一下发现了这个驾校一点通，因为有题目接口，而且完全没有反爬机制，一晚上就搞定了

直接存储所有题目到mysql数据库里，图片存储到本地文件夹内，如果这个文件夹在网站内，可以直接修改imageurl为网址存储到数据库里

然后写完了之后我也不知道有啥用，水篇博客吧

之所以会有这个文章是因为云计算赛项中获得了国赛二等奖, 发了奖金就给老电脑更新一点配件, 暂时买了一个NVME M.2转换PCI-E的转接卡, 金士顿骇客神条DDR3 8GB 1600 * 2, 希捷2TB 5900转硬盘, 影驰256GB NVME M.2固态硬盘

起因

最初我以为旧电脑中, 虽然没有NVME M.2的接口, 但是买一个转接卡转给PCI-E作为启动盘, 是没有什么问题的, 但是当我给SSD装好系统, 插上主板之后, 发现BIOS中无法选择PCI-E上的硬盘作为启动设备, 特征为不认盘, 就是在启动菜单中不显示PCI-E槽中的SSD, 经过笔者一整天的思考, 发现了三种方法解决这一个问题, 让没有M.2接口的旧主板作为启动设备

三种解决方案

1. 使用Clover这一类boot工具, 在进入boot manager后再选择SSD进行启动
2. 手动修改主板BIOS, 导入NVME模块, 使BIOS支持PCI-E硬盘引导
3. 将M.2 SSD转为USB, 开机使用USB作为启动设备

解决方案一: Clover

这里可以直接参考这个大佬的文章, 写的很详细

【教程】使用Clover启动Nvme协议的固态硬盘 - 哔哩哔哩 (bilibili.com)

解决方案二: 更新主板BIOS

事先提醒, 刷BIOS有风险

参考文章: mmtool——BIOS修改工具及添加nvme模块教程 - 『精品软件区』 - 吾爱破解 - LCG - LSG |安卓破解|病毒分析|www.52pojie.cn

如果你的主板是B85-PLUS R2.0, 那么可以用我在下面提供的BIOS进行操作, 这个是我亲测没问题的

https://cdn.nothamor.com/B85-PLUS-R2.0-NVME(Z97).zip

这个包的操作方法:

1. 准备一个空U盘, 新建一个BIOS文件夹, 将包中的三个文件放入其中

2. 准备一个PE启动U盘/DVD, 进入纯DOS模式(一定要纯DOS模式, 大白菜就有纯DOS)

3. 进入纯DOS模式后, 按照以下操作

   首先进入C盘, 输入: C:\后回车

   输入 dir后回车, 查看C盘下文件, 如果有BIOS文件夹, 则是正确, 如果没有BIOS文件夹, 依次输入 D:\等, 直到你找到BIOS文件夹

   输入 cd BIOS回车进入BIOS文件夹下, 再输入 dir查看当前目录下的所有文件, 如果有 AFUDOS.exe, NVME.ROM, START.bat三个文件的话, 则为正确, 直接输入 START.bat回车进行BIOS的刷写, 然后等待之后BIOS就刷写好了

   刷写好BIOS后输入 r回车, 进行重新启动, 这时候进入BIOS, 会发现启动设备多了一个Windows Boot Manager, 则为成功

4. 这时候工作还没有做完, SSD中的系统必须按照如下要求安装

   进入PE系统, 使用Disk Genius分区工具, 将PCI-E槽中的SSD硬盘进行格式化(格式化前备份好资料)

   格式化后, 选中SSD硬盘, 选择上方的快速分区, 分区表类型选择 GUID

   下方的分区数目可以自定义, 想要分几个区, 就选几个区, 一般这个SSD都是用于引导系统, 所以分一个区就够了, 给它全部空间

   在下方选择 重建主引导记录(MBR), 在右侧高级设置中分配分区空间

   一定要勾选右下角的 对齐分区到此扇区数的整数倍, 给默认值就好(2048扇区)

   然后确定, 这时候就分区好了

   只有PCI-E槽上的SSD需要这么分区, 其它硬盘按照正常分区方法进行分区就可以

5. 在分区之后, 使用Disk Genius工具清除 除了ESP, MSR分区以外的 所有分区盘符(就是C盘, D盘这些东西, 先给清掉)

6. 然后再使用Disk Genius工具, 给那些分区重新分配盘符, 但是 一定要给SSD的那个分区C盘, 其它的自己分就好 (ESP, MSR不用管)

7. 然后使用老毛桃PE中的 WinNTSetUp工具, 进行操作系统的安装, 位置在 开始菜单->所有程序->安装维护中, Windows安装源选择官方Windows10镜像, 引导驱动器选择刚才的ESP分区(这个ESP分区一定要在Disk Genius中和文件管理器中确认好), 安装驱动器选择C盘, 然后单击开始安装就好了

8. 安装完系统后进行重启, 重启后一定要进入BIOS确认好Windows Boot Manager在第一启动项, 确认好后按F10保存并重启

9. 重启后就进行系统的配置了, 这时候就已经结束了所有步骤了, Enjoy it!

解决方案三: M.2转USB

事先声明, 这个方案只是笔者想到的, 但是没有实践, 因为我使用解决方案二解决了我的问题, 但是我认为这个解决方案应该是可行的

就是淘宝买一个支持M.2转USB3.0的转接器, 然后插在电脑上, BIOS中选择USB启动, 选择这个USB, 应该没有问题

但是SSD的速度有可能被影响, 这个笔者没有试验过