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

目录

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

背景

硬件：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的速度有可能被影响, 这个笔者没有试验过

使用方法: 在传智播客视频播放页按F12, 将下面的代码粘贴到控制台里面, 回车即可运行 (本项目已在GitHub开源, 如果对你有用的话, 顺路给个starrrrrr吧!) [github repo="NothAmor/auto_chuanzhi" /]

console.log("欢迎使用传智自动播放插件, 作者博客:https://www.nothamor.com");
    setTimeout(function() {
        let url = window.location.href;
        if(url.includes("http://stu.ityxb.com/lookPaper/busywork/")) {
            auto_search();
            console.log("检测到为测试页面, 开始自动查询题目");
        } else if(url.includes("http://stu.ityxb.com/preview/detail/")) {
            auto_play();
            console.log("检测到为视频播放页面, 开始自动播放视频");
        }
    }, 5000);

    function auto_play() {
        const CLASS_LIST = document.getElementsByClassName("point-progress-box");
        const CLASS_NAME = document.getElementsByClassName("point-text ellipsis");
        let question_text = document.getElementsByTagName("pre")[0];
        let player = document.getElementsByTagName("video")[0].id;
        let question_text_value;
        document.getElementById(player).click();
        let counter = 0;
        const TIMER = setInterval(function () {
            let percent = CLASS_LIST[counter].innerHTML.replace(/\ +/g, "").replace(/[\r\n]/g, "");
            let title_name = CLASS_NAME[counter].innerHTML.replace(/\ +/g, "").replace(/[\r\n]/g, "");
            if (percent.includes("100%") && counter == (CLASS_LIST.length - 1)) {
                clearInterval(TIMER);
                alert("当前页所有视频均已播放完成");
            } else if (percent.includes("100%")) {
                CLASS_LIST[counter + 1].click();
                player = document.getElementsByTagName("video")[0].id;
                document.getElementById(player).click();
                counter++;
            }
            if (title_name.includes("习题")) {
                question_text = document.getElementsByTagName("pre")[0];
                question_text_value = question_text.innerHTML;
                console.log(" ");
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: 'http://jb.s759n.cn/chati.php?w=' + encodeURIComponent(QUESTION[counter].innerHTML),
                    headers: {
                        'Content-type': 'application/x-www-form-urlencoded',
                    },
                    data: 'q=' + encodeURIComponent(QUESTION[counter].innerHTML),
                    onload: function (response) {
                        if (response.status == 200) {
                            let obj = $.parseJSON(response.responseText.replace(/^操作数据失败！/, '')) || {};
                            obj.answer = obj.data;
                            console.log("题目:" + QUESTION[counter].innerHTML + "的答案为:" + obj.answer);
                            if (obj.code) {
                            } else {
                                console.log('服务器繁忙，正在重试...');
                            }
                        } else if (response.status == 403) {
                            console.log('请求过于频繁，建议稍后再试');
                        } else {
                            console.log('服务器异常，正在重试...');
                        }
                    }
                });
            }
        }, 1000);
    }
    function auto_search() {
        const QUESTION = document.getElementsByTagName("pre");
        let counter = 0;
        const SEARCH = setInterval(function() {
            GM_xmlhttpRequest({
                method: 'GET',
                url: 'http://jb.s759n.cn/chati.php?w=' + encodeURIComponent(QUESTION[counter].innerHTML),
                headers: {
                    'Content-type': 'application/x-www-form-urlencoded',
                },
                onload: function (response) {
                    if (response.status == 200) {
                        let obj = $.parseJSON(response.responseText.replace(/^操作数据失败！/, '')) || {};
                        console.log("第" + counter + "题" + "的答案为:" + obj.data);
                        if (obj.code) {
                        } else {
                            console.log('服务器繁忙，正在重试...');
                        }
                    } else if (response.status == 403) {
                        console.log('请求过于频繁，建议稍后再试');
                    } else {
                        console.log('服务器异常，正在重试...');
                    }
                }
            });
            counter++;
            if(counter == (QUESTION.length)) {
                clearInterval(SEARCH);
                console.log("题目搜索完成");
            }
        }, 1000);
    }

当然还有另外一个版本, 这个依赖于浏览器插件tampermonkey, 不用每次都手动去输入脚本内容 可以手动添加, 也可以直接在greasy fork上下载本脚本 greasy fork下载链接:https://greasyfork.org/zh-CN/scripts/405920-传智自动播放视频

// ==UserScript==
// @name         传智自动播放视频
// @namespace    http://tampermonkey.net/
// @version      0.3
// @description  自动播放传智播客课程视频, 开发者博客:http://www.nothamor.cn
// @author       nothamor
// @match        *.ityxb.com/*
// @grant        GM_xmlhttpRequest
// ==/UserScript==

(function() {
    'use strict';

    console.log("欢迎使用传智自动播放插件, 作者博客:https://www.nothamor.cn");
    setTimeout(function() {
        let url = window.location.href;
        if(url.includes("http://stu.ityxb.com/lookPaper/busywork/")) {
            auto_search();
            console.log("检测到为测试页面, 开始自动查询题目");
        } else if(url.includes("http://stu.ityxb.com/preview/detail/")) {
            auto_play();
            console.log("检测到为视频播放页面, 开始自动播放视频");
        }
    }, 5000);

    function auto_play() {
        const CLASS_LIST = document.getElementsByClassName("point-progress-box");
        const CLASS_NAME = document.getElementsByClassName("point-text ellipsis");
        let question_text = document.getElementsByTagName("pre")[0];
        let player = document.getElementsByTagName("video")[0].id;
        let question_text_value;
        document.getElementById(player).click();
        let counter = 0;
        const TIMER = setInterval(function () {
            let percent = CLASS_LIST[counter].innerHTML.replace(/\ +/g, "").replace(/[\r\n]/g, "");
            let title_name = CLASS_NAME[counter].innerHTML.replace(/\ +/g, "").replace(/[\r\n]/g, "");
            if (percent.includes("100%") && counter == (CLASS_LIST.length - 1)) {
                clearInterval(TIMER);
                alert("当前页所有视频均已播放完成");
            } else if (percent.includes("100%")) {
                CLASS_LIST[counter + 1].click();
                player = document.getElementsByTagName("video")[0].id;
                document.getElementById(player).click();
                counter++;
            }
            if (title_name.includes("习题")) {
                question_text = document.getElementsByTagName("pre")[0];
                question_text_value = question_text.innerHTML;
                console.log(" ");
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: 'http://jb.s759n.cn/chati.php?w=' + encodeURIComponent(QUESTION[counter].innerHTML),
                    headers: {
                        'Content-type': 'application/x-www-form-urlencoded',
                    },
                    data: 'q=' + encodeURIComponent(QUESTION[counter].innerHTML),
                    onload: function (response) {
                        if (response.status == 200) {
                            let obj = $.parseJSON(response.responseText.replace(/^操作数据失败！/, '')) || {};
                            obj.answer = obj.data;
                            console.log("题目:" + QUESTION[counter].innerHTML + "的答案为:" + obj.answer);
                            if (obj.code) {
                            } else {
                                console.log('服务器繁忙，正在重试...');
                            }
                        } else if (response.status == 403) {
                            console.log('请求过于频繁，建议稍后再试');
                        } else {
                            console.log('服务器异常，正在重试...');
                        }
                    }
                });
            }
        }, 1000);
    }
    function auto_search() {
        const QUESTION = document.getElementsByTagName("pre");
        let counter = 0;
        const SEARCH = setInterval(function() {
            GM_xmlhttpRequest({
                method: 'GET',
                url: 'http://jb.s759n.cn/chati.php?w=' + encodeURIComponent(QUESTION[counter].innerHTML),
                headers: {
                    'Content-type': 'application/x-www-form-urlencoded',
                },
                onload: function (response) {
                    if (response.status == 200) {
                        let obj = $.parseJSON(response.responseText.replace(/^操作数据失败！/, '')) || {};
                        console.log("第" + counter + "题" + "的答案为:" + obj.data);
                        if (obj.code) {
                        } else {
                            console.log('服务器繁忙，正在重试...');
                        }
                    } else if (response.status == 403) {
                        console.log('请求过于频繁，建议稍后再试');
                    } else {
                        console.log('服务器异常，正在重试...');
                    }
                }
            });
            counter++;
            if(counter == (QUESTION.length)) {
                clearInterval(SEARCH);
                console.log("题目搜索完成");
            }
        }, 1000);
    }
})();