imicola

浮游叙事——2025 年终总结

Wed, 31 Dec 2025 00:00:00 GMT

浮游叙事——2025 年终总结

年终，再过几个小时就意味着2025年的离去，在每一年在尽头的时候，我们都会不禁感慨到今年的一年过的是如此的迅速，时间从来都是最无情的，用不快不慢的速度在向着前面走去，仿佛一个独行的满腔执念的人一样，全然不顾周围。

每年的年终总结时间，想到的一个念头便是 “平凡”，甚至是枯燥。“平凡”的一年让我在回忆的时候无法想到最令我记忆深刻的事情，甚至无法让我回忆起什么事情是今年发生的，什么事情是去年发生的。人的记忆就是如此，去掉了一切不必要的，模糊的，细节的东西，只在脑海中留个“感觉”，这种感觉让我们能在看到照片时迸发，能在我们与好友交谈时突兀的冒出来，能在夜深人静的时候一个一个涌上心头。到内心充盈着这种回忆的感情的时候，我们不由得发现————2025好像也没那么枯燥。

今年感受最深的一句话来自平台跳跃游戏蔚蓝中的“你能做到”。过去我总是用一种谨慎的，怀疑的目光来审视自己，以至于我开始就丧失了去做一件事情的动力。但是很多时候，我只是需要一个开始的理由，一个把行动的小球从高处推下的动力源。“你能做到”就是给我的这样的一个动力，没有什么利弊权衡，只是对未来自己的相信，对自己潜力的自信。

一年的时间如此迅速，但是又如此漫长，我的生活被一条跨越中国南北的铁道线划成上下册；上册我在南方，回过荔园，去过珠海。在盛夏中看过海与烟花，和一群重要的人度过了高中生活的开朗DLC；下册我来到了北方，见过北方的风和雪，看过长春的地上跑的地铁，看过北京的天安门，见到了哈尔滨的雪花一层一层积累，在这里与另外一群重要的人度过了大学篇续作的第二章。这一切似乎看起来都是一些零零碎碎的小故事，但是一年怎么就不是这些小事日常拼凑起来的呢？

当我真的去好好看看一年都不怎么回首的2025时候，也不免会发现一切都变了很多。从我到这个世界，变化不息。我们已经很难想象，在25年年初deepseek R1才被推出，我们也很难想象去年才高三的生活，明年要变成大三了。这种变化悄然的改变我们的生活和日常，如同一名初学者落入水中一般，浮游着摆动着。世界是大海，带来的浪花敲击着我们，我们在浪花的摇摆下浮游的记录着生活的故事。

世界在网络线下，将我的生活再次划分为二,一面是引力沉重的现实，一面是飘浮着的数据；在那个现实的反面，在费伦的一个“小城”里体验过史诗的故事,登上过塞莱斯特的山顶，在银河系下看过文明的太空歌剧，在一个奇怪的井里找过蛋和兔子。同样的我见过了一个支离破碎的乐队变成两个乐队的故事，看过一个没有一个人却详细刻画了整个人类文明的故事。在另一种意义的浮游叙事下，我是参与者，亦是欣赏者，看向浮动的世界。

2025亦有有些遗憾之事，我的打A之路并没有什么能拿的出手的牌子，有本想看的书一直只翻开的序章，许许多多的未完成，未成功依旧留在2025，并且会随着我一起带到2026。2025不是完美的，正如每一个年份都不是完美的一样，缺陷与遗憾仍然是2025组成的部分甚至是绝大部分。

但是，你能做到，不是吗？

2025和2024，2026没有本质区别，是银河系猎户臂下一个小小星系团的一个类地行星绕着它的恒星一圈的时间而已。因为有人的存在，我们赋予机械而物理的事实以意义，将岁月的印记留在岁月之中，这是属于人的浪漫。正如我上面说的，我们因为生活在世界的海洋中，所以我们需要锚点需要叙事需要存在的意义。人类就在这样不断压缩自己的过去的路上走向未来，望向过去只觉得短暂，看向未来又觉得漫长。

生活细碎，万物成诗

祝好，2026

命令行的艺术(上)

Mon, 12 Oct 2026 00:00:00 GMT

本文是来自对命令行的艺术的拙劣模仿，结合了一些笔者的实际使用经验，得到的一个，"如何配置好看且顺手的命令行" 的小教程吧

终端环境

一个好的终端环境对命令行的配置至关重要，如果你的终端不能配置字体，不支持流输出，不支持背景图片配置，那我只能说你不是一个合格的 "技术宅"(

笔者没怎么用过真机Linux，在此不做推荐。

而 Windows 上，首推 Window Terminal (wt) ,作为微软良心且开源的产品，wt 预安装在每个 Windows 用户的设备上, 拥有丰富的配置选项, 只不过大部分人都不知道怎么将一个黑色的,使用微软雅黑中文字体显示英文符号的超级无敌对比度的初始终端(或许是蓝色?)配置成好看的窗口

选择一个shell

在配置终端前，先选择一个适合自己的 shell 环境, 如果你是一个小白，那么你的默认 shell 环境大概率是 powershell 5 ,它已经过时了,现在建议你升级到powershell 7 ，如果你有Agent或者Harness,告诉它需求，它会帮你的;如果没有，你可以尝试去 github 下载安装包，或者使用 winget install pwsh 命令，使用 winget 包管理器完成安装

下载安装完成后，你可能需要重启一次你的 wt 来导入 pwsh7 的配置文件，然后使用快捷键 ctrl + ， 进入 wt 的配置界面，在 "启动" 选项卡中选择 powershell 作为你的默认配置文件，如果这里有两个 powershell ,选择黑色的那个

当然，如果你更加熟悉bash语法环境,你也可以试试用 git bash 作为主力终端，使用 git bash 的另外一个好处就是: 在你跑一些 Agent 的时候, LLM不会和 pwsh 语法斗殴 (笔者现在主力用6.1sol也会经常出现和pwsh语法打架的环节)

配置这个 shell 窗口

在 wt 的设计界面，左侧的选项卡向下滑，应该能看见你 wt 上 shell 的配置文件，请直接修改 其他设置-外观 ,除此以外的配置尽量保持默认选项，除非你真的知道你自己在干什么

进入外观后，可以看到第一个配色方案文本，可以挑选自己喜爱的配色方案设置，但是说实话，wt 自带的配色方案不敢说好看喵，这里推荐一个配色方案合集 catppuccin ,这个提供了一整套好看的配色，而且覆盖了很多常见，对于我们需要的 wt 配色，这个项目就提供了解决方案，当然你现在直接看我下面的设置就行了，或者你直接让你的大模型帮你设置(~~实际上这个文章中的所有内容大模型都可以帮你做好，你只需要知道改了什么就行~~)

在当前页面，你应该能看见一个「打开JSON文件」的按钮
使用任意能编辑文件的编辑器打开,vscode,zed,甚至是记事本
在这里选择一个你喜欢的配色方案 (frappe, latte, macchiato, mocha).json 和与其对应的 XXXTheme.json
将 不带Theme 的文件内容(如macchiato.json)复制，并且如下面的格式粘贴到 wt 的配置文件中

{
	// 你的其他配置 (注意wt json不允许注释,这一行要删)
	"schemes":
	[
		{
			"background": "#24273A",
			"black": "#494D64",
			"blue": "#8AADF4",
			"brightBlack": "#5B6078",
			"brightBlue": "#8AADF4",
			"brightCyan": "#8BD5CA",
			"brightGreen": "#A6DA95",
			"brightPurple": "#F5BDE6",
			"brightRed": "#ED8796",
			"brightWhite": "#A5ADCB",
			"brightYellow": "#EED49F",
			"cursorColor": "#F4DBD6",
			"cyan": "#8BD5CA",
			"foreground": "#CAD3F5",
			"green": "#A6DA95",
			"name": "Catppuccin Macchiato",
			"purple": "#F5BDE6",
			"red": "#ED8796",
			"selectionBackground": "#5B6078",
			"white": "#B8C0E0",
			"yellow": "#EED49F"
		}
	],
}

将 带Theme 的文件内容(如macchiatoTheme.json)复制，并且如下面的格式粘贴到 wt 的配置文件中

{
	"themes":
	[
		{
			"name": "Catppuccin Macchiato",
			"tab":
			{
				"background": "#24273AFF",
				"iconStyle": "default",
				"showCloseButton": "always",
				"unfocusedBackground": null
			},
			"tabRow":
			{
				"background": "#1E2030FF",
				"unfocusedBackground": "#181926FF"
			},
			"window":
			{
				"applicationTheme": "dark",
				"experimental.rainbowFrame": false,
				"frame": null,
				"unfocusedFrame": null,
				"useMica": false
			}
		}
	],
}

注意这里的两个 json 键都是一级,不要放到其他的键下了

保存，然后退出这个 json 文件的编辑
回到你的 shell 的配置界面，选择配色方案选项，现在你加入的主题应该会在选择框中
选择它即可

然后是「字体」选项，你应该选择一个 "好看且多功能" 的字体集，好看是指字体在代码阅读层面是清晰且分明的，多功能指字体可以承担部分"字符集"的作用，这里特指带 Nerd 或者 NF 表示的字体，例如 JetBrainsMono Nerd Font，但是我这里更加推荐 Maple Mono NF CN

你可以在字体下载 | Maple Mono 这里下载，也可以直接点击这里下载

下载完成后你会得到一个压缩包,解压后在解压出来的文件夹中按下 ctrl + a全选文件，右键后找到 "安装" 选项，如果没有，请在 "显示更多选项" 中查找

安装完成后就可以回到 shell 的字体配置，选择刚刚安装好的 Maple Mono NF CN 使用即可

接下来的一些配置，基本都是字面意思, 「字号」「行高」「单元格宽度」保持默认即可

往下滑可以看到「背景图像路径」,优秀技术宅都会选择一张适合自己的图片作为终端背景喵(

「拉伸模式」选择「均匀填充」,对齐选择 "居中"，不透明度选择 10% 最好(太高了容易看不清字)

下面的有个「透明度」设置，可以选择 75% 左右，然后根据个人喜好配置「是否启用亚克力效果」，反正 imicola 是挺喜欢的

配置 Shell

要想 shell 好用，不光是 shell 的窗口，shell 本身也值得精细配置，下面我会讲述linux 的 Zsh 和 pwsh 的关于我自己是如何配置的，当然你也可以自己选择你喜欢的方式，去折腾这一圈东西

Zsh配置

先看效果:

要实现这样的效果，我们首先需要安装系统包，使用你对应的发行版(imicola这里是Arch)安装

sudo pacman -S zsh eza fzf fastfetch

然后我们这个是以 oh-my-zsh 为框架的命令行系统,安装 oh-my-zsh 并且将 zsh 设定为 默认shell

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" "" --unattended
chsh -s /usr/bin/zsh

接着我们装 spaceship 主题，当然你也可以选择你喜欢的主题

ZSH_CUSTOM="${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}"
git clone https://github.com/spaceship-prompt/spaceship-prompt.git "$ZSH_CUSTOM/themes/spaceship-prompt" --depth=1
ln -s "$ZSH_CUSTOM/themes/spaceship-prompt/spaceship.zsh-theme" "$ZSH_CUSTOM/themes/spaceship.zsh-theme"

随后是 oh-my-zsh 的两个第三方插件，分别用来显示补全和命令高亮

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

随后可以装 autojump ,这个命令会解析你经常去的目录，随后使用 j 命令 jump 到这个目录里，相当好用

git clone https://gitee.com/lxgyChen/autojump
cd autojump && ./install.py

比如我经常访问/home/imicola/imicola_resource/SRE_Devops/Go 这个目录，我们就可以用 j go 达到这个直接跳转到这个目录的效果

22:47:57 with imicola in ~ via ⬢ v25.2.1 via 🍞 v1.3.6
➜ j go
/home/imicola/imicola_resource/SRE_Devops/Go

随后是对 .zshrc 的配置，将这个配置加入你的 .zshrc 并且解决冲突后就可以使用

export ZSH="$HOME/.oh-my-zsh"
ZSH_THEME="spaceship"

plugins=(
	git
	sudo
	copypath
	copyfile
	autojump
	zsh-syntax-highlighting   # 官方要求：必须放最后
	zsh-autosuggestions
)

source $ZSH/oh-my-zsh.sh

# autojump 源码版补加载（omz 的 autojump 插件只负责初始化）
[[ -s $HOME/.autojump/etc/profile.d/autojump.sh ]] && source $HOME/.autojump/etc/profile.d/autojump.sh

# spaceship 微调：常显时间戳、常显粉色用户名
SPACESHIP_TIME_SHOW="true"
SPACESHIP_USER_SHOW="always"
SPACESHIP_USER_COLOR="212"

# alias
alias cls="clear"
alias vi="nvim"
alias vim="nvim"
alias ls="eza --icons --group-directories-first"

# fzf 键绑定（Ctrl+R 模糊历史、Ctrl+T 模糊文件，ALT+C 模糊目录）
source <(fzf --zsh)

有两个包没说，一个是 eza ,相当与增强版的 ls，使用 alias ls="eza --icons --group-directories-first" 则可以达到下图样式

还有一个是 fzf ,作用是 Ctrl+R 模糊历史、Ctrl+T 模糊文件，ALT+C 模糊目录

随后是 二次元男娘 时尚单品 fastfetch 的配置

在 ~/.config/fastfetch 中找到 config.jsonc 然后配置它

如果你想要 imicola 的配置，直接抄下面这份 config.jsonc 就行，其中，logo 的配置使用的是 MurthiNext/img2text: 将图片转换为带有 ANSI 颜色代码的字符画。这个开源项目喵

<details> <summary>点开查看完整 config.jsonc</summary>

{
  "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/master/doc/json_schema.json",

  // ═══════════════════════════════════════════════════════════════
  //  Fastfetch Config — Tree-style with color-coded sections
  // ═══════════════════════════════════════════════════════════════
  //
  //  Color scheme:
  //    {#35} magenta  — Section headers
  //    {#33} yellow   — System section
  //    {#32} green    — Hardware section
  //    {#34} blue     — Software section
  //    {#36} cyan     — Network section
  //    {#31} red      — Extras section
  //
  //  To switch logos, change the "type" field:
  //    "small"  → Small Arch ASCII logo (current, works everywhere)
  //    "chafa"  → Custom image as colored ASCII art (needs source/width/height)
  //    "kitty"  → Kitty image protocol (Kitty terminal only)
  //    "sixel"  → Sixel graphics (WezTerm, etc.)
  //    "arch"   → Full-size Arch ASCII logo
  //
  //  To add more modules, follow the tree pattern:
  //    First item:  "key": "╭─ icon"
  //    Middle item: "key": "├─ icon"
  //    Last item:   "key": "╰─ icon"
  //
  //  Available modules: fastfetch --list-modules
  // ═══════════════════════════════════════════════════════════════

  // ── Logo ───────────────────────────────────────────────
  // Option A: Small Arch ASCII logo (default, universal)
  "logo": {
    "type": "auto",
    "source": "~/.config/fastfetch/b.txt",
    "padding": {
      "top": 1,
      "left": 1,
      "right": 3
    }
  },

  // Option B: Custom image via chafa (uncomment to use, comment Option A)
  // "logo": {
  //   "type": "auto",
  //   "source": "~/.config/fastfetch/b.txt",
  //   "width": 28,
  //   "height": 18,
  //   "padding": { "top": 1, "left": 1, "right": 2 }
  // },

  // ── Display ────────────────────────────────────────────
  "display": {
    "separator": "  ",
    "constants": [
      "──────────────────────────────"  // {$1} horizontal rule
    ],
    "percent": {
      "type": 3,         // 1=number, 2=bar, 3=both, 9=colored number
      "width": 0         // 0 disables fixed-width padding (no leading spaces)
    },
    "bar": {
      "char": {
        "elapsed": "■",
        "total": "□"
      }
    }
  },

  // ── Modules ────────────────────────────────────────────
  "modules": [
    // ── Title ──────────────────────────────────────────
    {
      "type": "title",
      "color": {
        "user": "35",
        "at": "90",
        "host": "35"
      }
    },
    {
      "type": "separator",
      "outputColor": "90"
    },

    // ── System ─────────────────────────────────────────
    {
      "type": "custom",
      "format": "{#35} {#1}System{#}"
    },
    {
      "type": "os",
      "key": "╭─ {icon}",
      "keyColor": "33"
    },
    {
      "type": "host",
      "key": "├─ 󰌢",
      "keyColor": "33"
    },
    {
      "type": "kernel",
      "key": "├─ ",
      "keyColor": "33"
    },
    {
      "type": "uptime",
      "key": "├─ 󰅐",
      "keyColor": "33"
    },
    {
      "type": "packages",
      "key": "╰─ 󰏖",
      "keyColor": "33"
    },

    // ── Hardware ───────────────────────────────────────
    {
      "type": "custom",
      "format": "{#32} {#1}Hardware{#}"
    },
    {
      "type": "cpu",
      "key": "╭─ 󰻠",
      "keyColor": "32",
      "format": "{name} ({cores-logical})"
    },
    {
      "type": "gpu",
      "key": "├─ 󰍛",
      "keyColor": "32"
    },
    {
      "type": "memory",
      "key": "├─ 󰑭",
      "keyColor": "32"
    },
    {
      "type": "swap",
      "key": "├─ 󰓡",
      "keyColor": "32"
    },
    {
      "type": "disk",
      "key": "╰─ ",
      "keyColor": "32",
      "folders": "/"
    },

    // ── Software ───────────────────────────────────────
    {
      "type": "custom",
      "format": "{#34}󰘳 {#1}Software{#}"
    },
    {
      "type": "wm",
      "key": "╭─ ",
      "keyColor": "34"
    },
    {
      "type": "shell",
      "key": "├─ ",
      "keyColor": "34"
    },
    {
      "type": "terminal",
      "key": "╰─ ",
      "keyColor": "34"
    },

    // ── Network ────────────────────────────────────────
    {
      "type": "custom",
      "format": "{#36}󰛳 {#1}Network{#}"
    },
    {
      "type": "localip",
      "key": "╰─ 󰩟",
      "keyColor": "36",
      "compact": true,
      "format": "{ipv4} ({ifname})"
    },

    // ── Extras ─────────────────────────────────────────
    {
      "type": "custom",
      "format": "{#31} {#1}Extras{#}"
    },
    {
      "type": "battery",
      "key": "╭─ 󰁹",
      "keyColor": "31"
    },
    {
      "type": "display",
      "key": "├─ 󰍹",
      "keyColor": "31"
    },
    {
      "type": "locale",
      "key": "╰─ 󰒍",
      "keyColor": "31"
    },

    // ── Bottom ─────────────────────────────────────────
    "break",
    {
      "type": "colors",
      "paddingLeft": 2,
      "symbol": "circle"
    }
  ]
}

</details>

pwsh配置

Linux 这边讲完了，回到 Windows 这边，pwsh 的配置思路和 zsh 不太一样: zsh 那边是 oh-my-zsh 框架 + 主题 + 一堆插件，而 pwsh 没有这样统一的框架，我们直接用 starship 这个跨 shell 的提示符工具接管外观，再补两个官方模块，最终效果和 zsh 那边几乎一个样——毕竟 imicola 的 starship 配置就是照着 spaceship 主题的样子调的

需要装的东西一共四个，两个走 winget，两个走 pwsh 自己的模块仓库 PSGallery:

winget install --id Starship.Starship
winget install --id junegunn.fzf

Install-Module PSFzf -Scope CurrentUser
Install-Module CompletionPredictor -Scope CurrentUser

(第一次用 PSGallery 会问你要不要信任这个仓库，回答 A 就行)

各自的分工:

starship: 跨 shell 的提示符工具，负责外观，对应 zsh 那边的 spaceship
PSFzf: fzf 的 pwsh 集成版，对应 zsh 那边的 source <(fzf --zsh)，管 Ctrl+R 模糊历史 / Ctrl+T 模糊文件 / Alt+C 模糊目录，真正干活的还是 winget 装的那个 fzf.exe，模块只是壳
CompletionPredictor: 微软官方的历史预测模块，Tab 补全列表里那条灰色的"你想输入的其实是这个"就是它
PSReadLine: pwsh 自带，连装都不用装，负责基础的行编辑和灰色历史预测

然后是配置文件。直接 notepad $PROFILE 打开编辑核心配置就这几行:

Invoke-Expression (&starship init powershell)
Import-Module PSFzf
Import-Module CompletionPredictor

# PSReadLine: 从历史生成预测，列表视图展示
Set-PSReadLineOption -PredictionSource History
Set-PSReadLineOption -PredictionViewStyle ListView

# Ctrl+R 先绑成清屏，给 PSFzf 挂掉时留个保底
Set-PSReadLineKeyHandler -Key Ctrl+r -Function ClearScreen

# PSFzf 键位: 后面的绑定会覆盖上面的 Ctrl+R，最终生效的是这里
Set-PsFzfOption -PSReadlineChordProvider 'Ctrl+t'
Set-PsFzfOption -PSReadlineChordReverseHistory 'Ctrl+r'
Set-PsFzfOption -PSReadlineChordSetLocation 'Alt+c'

starship 的配置在 ~\.config\starship.toml，想让提示符和 imicola 长一个样的话，直接抄下面这份 starship.toml，核心思路如下:

palette = 'catppuccin_mocha'，直接用 Catppuccin Mocha 调色板(文件尾部自带整套色值)，和 wt 端的 Catppuccin 配色无缝衔接
format 显式排布一行信息: 时间 → 用户名 → 目录 → git 分支 → 语言版本 → 上条命令耗时，然后换行，第二行只剩一个箭头
character 里成功绿箭头、报错红箭头——对，就是 zsh 那个 ➜，两套 shell 刻意统一了视觉，切来切去没有陌生感

<details> <summary>点开查看完整 starship.toml</summary>

"$schema" = 'https://starship.rs/config-schema.json'

add_newline = false
palette = 'catppuccin_mocha'

# Keep a clean, zsh-like one-line info prompt and a second-line character.
format = """
$time\
$username\
$directory\
$git_branch\
$git_status\
$package\
$c\
$cpp\
$cmake\
$rust\
$golang\
$nodejs\
$php\
$java\
$kotlin\
$haskell\
$python\
$conda\
$cmd_duration\
$line_break\
$character"""

[time]
disabled = false
time_format = "%T"
style = "fg:lavender"
format = '[$time]($style) '

[username]
show_always = true
style_user = "fg:pink"
style_root = "bold fg:red"
format = 'with [$user]($style) '

[directory]
style = "fg:teal"
format = 'in [$path]($style)[$read_only]($read_only_style) '
read_only = " 󰌾"
read_only_style = "fg:red"
truncation_length = 3
truncation_symbol = "…/"

[directory.substitutions]
"Documents" = "󰈙 "
"Downloads" = " "
"Music" = "󰝚 "
"Pictures" = " "
"Developer" = "󰲋 "

[git_branch]
symbol = " "
style = "fg:mauve"
format = 'on [$symbol$branch]($style) '

[git_status]
style = "fg:yellow"
format = '([$all_status$ahead_behind]($style) )'

[package]
symbol = "󰏗 "
style = "fg:peach"
format = 'is [$symbol$version]($style) '

[c]
symbol = " "

[cpp]
symbol = " "

[cmake]
symbol = " "

[rust]
symbol = "󱘗 "

[golang]
symbol = " "

[nodejs]
symbol = " "

[php]
symbol = " "

[java]
symbol = " "

[kotlin]
symbol = " "

[haskell]
symbol = " "

[python]
symbol = " "

[conda]
symbol = " "
style = "fg:sky"
format = 'via [$symbol$environment]($style) '
ignore_base = true

[cmd_duration]
min_time = 500
show_milliseconds = true
style = "fg:overlay2"
format = 'took [$duration]($style) '
disabled = false
show_notifications = true
min_time_to_notify = 45000

[line_break]
disabled = false

[character]
disabled = false
success_symbol = '[➜](bold fg:green) '
error_symbol = '[➜](bold fg:red) '
vimcmd_symbol = '[❮](bold fg:green) '
vimcmd_replace_one_symbol = '[❮](bold fg:lavender) '
vimcmd_replace_symbol = '[❮](bold fg:lavender) '
vimcmd_visual_symbol = '[❮](bold fg:yellow) '

# Nerd Font Symbols preset mappings (selected core set + OS table)
[aws]
symbol = " "

[buf]
symbol = " "

[bun]
symbol = " "

[crystal]
symbol = " "

[dart]
symbol = " "

[deno]
symbol = " "

[docker_context]
symbol = " "

[elixir]
symbol = " "

[elm]
symbol = " "

[fennel]
symbol = " "

[fortran]
symbol = " "

[fossil_branch]
symbol = " "

[gcloud]
symbol = " "

[git_commit]
tag_symbol = '  '

[gradle]
symbol = " "

[guix_shell]
symbol = " "

[haxe]
symbol = " "

[hg_branch]
symbol = " "

[hostname]
ssh_symbol = " "

[julia]
symbol = " "

[lua]
symbol = " "

[memory_usage]
symbol = "󰍛 "

[meson]
symbol = "󰔷 "

[nim]
symbol = "󰆥 "

[nix_shell]
symbol = " "

[ocaml]
symbol = " "

[perl]
symbol = " "

[pijul_channel]
symbol = " "

[pixi]
symbol = "󰏗 "

[rlang]
symbol = "󰟔 "

[ruby]
symbol = " "

[scala]
symbol = " "

[status]
symbol = " "

[swift]
symbol = " "

[xmake]
symbol = " "

[zig]
symbol = " "

[os.symbols]
Alpaquita = " "
Alpine = " "
AlmaLinux = " "
Amazon = " "
Android = " "
AOSC = " "
Arch = " "
Artix = " "
CachyOS = " "
CentOS = " "
Debian = " "
DragonFly = " "
Elementary = " "
Emscripten = " "
EndeavourOS = " "
Fedora = " "
FreeBSD = " "
Garuda = "󰛓 "
Gentoo = " "
HardenedBSD = "󰞌 "
Illumos = "󰈸 "
Ios = "󰀷 "
Kali = " "
Linux = " "
Mabox = " "
Macos = " "
Manjaro = " "
Mariner = " "
MidnightBSD = " "
Mint = " "
NetBSD = " "
NixOS = " "
Nobara = " "
OpenBSD = "󰈺 "
openSUSE = " "
OracleLinux = "󰌷 "
Pop = " "
Raspbian = " "
Redhat = " "
RedHatEnterprise = " "
RockyLinux = " "
Redox = "󰀘 "
Solus = "󰠳 "
SUSE = " "
Ubuntu = " "
Unknown = " "
Void = " "
Windows = "󰍲 "
Zorin = " "

[palettes.catppuccin_mocha]
rosewater = "#f5e0dc"
flamingo = "#f2cdcd"
pink = "#f5c2e7"
mauve = "#cba6f7"
red = "#f38ba8"
maroon = "#eba0ac"
peach = "#fab387"
yellow = "#f9e2af"
green = "#a6e3a1"
teal = "#94e2d5"
sky = "#89dceb"
sapphire = "#74c7ec"
blue = "#89b4fa"
lavender = "#b4befe"
text = "#cdd6f4"
subtext1 = "#bac2de"
subtext0 = "#a6adc8"
overlay2 = "#9399b2"
overlay1 = "#7f849c"
overlay0 = "#6c7086"
surface2 = "#585b70"
surface1 = "#45475a"
surface0 = "#313244"
base = "#1e1e2e"
mantle = "#181825"
crust = "#11111b"

</details>

碎碎念:

有人问 imicola ，在这个 LLM 都快接管互联网的时代下，花那么多心思去配置一个几十年前的终端和命令行工具，是不是在浪费时间? AI 在使用命令行这一块使用已经远远超越人类程序员，我们不用命令行也能做到很多事情，甚至可以做到我们在图形化界面上都做不到的事情

但是呢，这种甚至有一点开倒车的，花费心思去配置一个好看的命令行，实际上也是类似一种 "消遣" 的心态，配置就如同搭积木一般，看着一个黑乎乎的窗口成为自己得心应手的工具，算是一种娱乐行为吧（

Prometheus 从指标暴露到抓取实战

Sun, 11 Oct 2026 00:00:00 GMT

prometheus(普罗米修斯)是一个系统和服务监控系统，普罗米修斯可以按给定间隔从配置的目标收集指标，评估规则表达式，显示结果，并可在观察到指定条件时触发告警

Prometheus抓取什么

在生产环境中，Prometheus一般运行在云端中，通过HTTP协议抓取集群中各个节点暴露的端口，而不是自己作为一个Agent去收集集群节点的环境

这就涉及到一个约定问题，普罗米修斯如何正确的读取到节点返回的响应?

metrics定义与Gauge文本格式

我们先明确三个定义:

指标（Metric）：一个带有明确名称和单位的测量值，HTTP 接口只是把这次测量值交给外部读取的传输载体
仪表盘指标（Gauge）：表示当前状态的瞬时测量值，数值可以上升也可以下降。可用内存随进程分配与释放而波动，符合 Gauge 的特征
单调递增计数器（Counter） 仅适合累计事件次数（通常只增不减，仅在进程重启时重置），比如累计CPU时间
Exposition Format（指标暴露格式）：提供一个能被监控程序读取的接口规范

我们这节用 go 语言抓取 /proc/meminfo 中的 MemAvailable 来展示，所以 MemAvailable 的值(乘1024) 便是我们这次的指标

对于 Exposition Format ，我们自然的采用 Prometheus 传统 HTTP 文本暴露格式 这个格式将在下面介绍

一次成功的 /metrics 响应由响应头和三行响应体组成。

其中响应头指定协议版本与编码：

Content-Type: text/plain; version=0.0.4; charset=utf-8

响应体我们约定为三行文本:

# HELP sentinel_memory_available_bytes Estimated available memory in bytes.
# TYPE sentinel_memory_available_bytes gauge
sentinel_memory_available_bytes 2097152

其基本构造:

# HELP [] {Explanation}
# TYPE [] {type}
[] {numerical value}

这三行的含义定义可以这样解释:

# HELP 行说明指标含义
# TYPE 行声明类型(如 gauge,counter)
最后一行表示样本行，是这次暴露的数据

其中三行中的指标名称必须一致，同时每行的末尾都必须带换行符 \n

Prometheus如何抓取

当我们实现了接口之后，我们就需要自己配置一下普罗米修斯来实现对节点内容的定期抓取了

首先我们先了解分工和整体流程:

sequenceDiagram
    autonumber
    participant P as Prometheus Server (:9091)
    participant S as sentinel-go (:9090)

    Note over P: 主动拉取（Pull）模型：Prometheus 按周期主动 GET /metrics

    rect rgb(232, 244, 255)
    Note over P: T0 [0s]
    P->>S: GET /metrics
    S-->>P: 200 OK (sentinel_memory_available_bytes 2097152)
    Note over P: TSDB 写入：(T0, 2097152), up=1
    end

    rect rgb(232, 251, 234)
    Note over P: T1 [5s]（周期调度）
    P->>S: GET /metrics
    S-->>P: 200 OK (sentinel_memory_available_bytes 2085600)
    Note over P: TSDB 写入：(T1, 2085600), up=1
    end

    Note over P: 抓取时刻时间戳以 Prometheus 记录为准，受网络与调度影响存在微小毫秒抖动

[!note]

谁发请求：Prometheus 是主动拉取（Pull）模型。Prometheus 作为客户端，按照配置的时间周期（如每 5 秒一次）主动向被监控服务发送 HTTP GET /metrics 请求。go 服务只需要被动监听端口并响应，不在代码内部维持抓取定时器

谁保存历史：Go 服务是无状态的采集端，处理完一次请求后数据即在内存中丢弃；Prometheus Server 内部集成时序数据库（TSDB）,每次拉取成功后会把当前样本值与抓取时刻的时间戳（精确到毫秒）持久化写入磁盘

数据库有什么好处：写入 Prometheus TSDB 之后的数据成为时间序列（Time Series），可以通过 PromQL 跨越时间轴计算波动、对齐不同实例、进行单位换算与阈值比对。

Prometheus中的逻辑

在Prometheus中，获取到的

Target（目标）：具体被抓取的网络端点，形式严格约定为 host:port（例如 127.0.0.1:9090）。一个 Target 对应一个暴露指标的 HTTP 进程实例
Job（作业）：一组执行相同业务逻辑或具有相同监控目的的 Target 集合；可以理解为一组意图相同的Target集合
Instance（实例）：当 Prometheus 完成抓取时，会自动在时序数据上打上 instance="<host:port>" 标签。job 与 instance 共同标识了抓取来源目标，也就是Instance是Job下的一个具体角色

存放在Prometheus中的时间序列中单个样本的逻辑表示可抽象为：

指标名{标签名="标签值", ...} 浮点数值 毫秒时间戳

比如

sentinel_memory_available_bytes{job="sentinel", instance="127.0.0.1:9090"} 2097152000 1760000000000

解读下来就是我们的指标，然后是这个指标属于哪个job，来自哪个Target，具体的数值是什么，最后是时间戳

抓取配置与地址格式

Prometheus 通过根配置文件（通常为 prometheus.yml）声明抓取行为

下面我们给出一个最小配置实例：

global:
  scrape_interval: 5s     # 抓取周期：每隔 5 秒发一次 GET 请求
  scrape_timeout: 4s      # 抓取超时：单次请求超过 4 秒未完成则判定为失败

scrape_configs:
  - job_name: 'sentinel'
    metrics_path: '/metrics'    # 抓取路径（默认即为 /metrics，显式声明）
    static_configs:
      - targets: ['127.0.0.1:9090']  # 必须写 host:port，不能带 http://

其中有几个要点需要我们知道：

Target 格式严禁包含协议与路径
- 即targets: ['127.0.0.1:9090']不能写成 ['http://127.0.0.1:9090'] 或者 ['127.0.0.1:9090/metrics']
超时时间不得超过抓取周期
- 如果超时时间大于抓取周期，当前周期的抓取还未结束就会与下一周期的抓取重叠堆积

可以参考 Prometheus 配置官方规范来编写扩展 prometheus.yml文件，在编写完成后，需要进行一次 promtool check config <文件名> 进行静态检查

Go net/http 从入门到 CRUD 实战

Fri, 04 Sep 2026 00:00:00 GMT

从一个请求的链路开始

当我们从客户端向服务器发送 HTTP 请求的时候，Go 语言有一套专门负责解析、构造的标准库 net/http。本文先从一个简单的 GET /healthz 实例引入 HTTP Server，接着梳理 HTTP Method 的语义，最后基于 Go 1.22 的方法路由实现一套完整的 CRUD 服务。

HTTP 服务链路

假设我们的客户端构造一个 8080 端口的 GET /healthz 请求，而服务端需要返回 HTTP 200 OK，这其中基本的链路如下：

客户端连接 8080 端口
→ Go HTTP Server 读取并解析 HTTP 请求
→ 路由器根据请求路径寻找 Handler
→ /healthz 匹配到 healthz 函数
→ healthz 读取请求 r
→ 通过 w 写回响应

想要完成上面的链路，需要涉及如下的方法：

net/http.ListenAndServe
net/http.HandleFunc
net/http.HandlerFunc
net/http.ResponseWriter
net/http.Request

我们接下来逐一讲解这些基本方法。

HandleFunc

func http.HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))

HandleFunc 是注册函数，负责在默认路由器中把 pattern 表示的路径与 handler 函数关联起来。

例如：

http.HandleFunc("/healthz", healthz)

表示将 /healthz 与函数 healthz 绑定并且注册到默认路由器中。这个操作并不会直接进入 healthz 函数中，真正的调用发生在请求到达之后。

ListenAndServe

func http.ListenAndServe(addr string, handler http.Handler) error

这个函数接受一个 TCP 地址，例如 IPv4:Port。本地测试时可以写成 :Port，其中省略的是具体主机地址，通常表示监听本机所有可用网络接口，并不等同于只监听 localhost；客户端仍可使用 localhost:Port 访问。

这个函数的作用是启动一个 HTTP Server，在第一个参数指定的地址上监听，并把收到的请求交给第二个参数代表的 Handler 处理。

这里有一点需要注意的是，当我们没有手写 mux 的时候这里可以填入 nil，这代表请求会被 DefaultServeMux 处理。

HandlerFunc

HandlerFunc 是标准库定义的命名函数类型。

type HandlerFunc func(ResponseWriter, *Request)

HandlerFunc 实现了 Handler 接口，可以把签名匹配的普通函数适配为 HTTP Handler。原始 HTTP 数据到 Request 对象的解析由 HTTP Server 完成，在进入 Handler 前已经完成。

Request

在函数内部，Request 不负责执行底层解析，而是让我们读取解析后的请求信息。

其常见的内容如下：

r.Method      // GET、POST 等请求方法
r.URL         // 路径和查询参数
r.Header      // 请求头
r.Body        // 请求体
r.Context()   // 请求上下文和取消信号

ResponseWriter

ResponseWriter 可以理解为你向客户端写回 HTTP 响应的出口。

对于一个 HTTP 响应，主要分为三部分：

HTTP/1.1 200 OK                   → 状态行
Content-Type: application/json    → 响应头

{"status":"ok"}                   → 响应体

因此，代码中的函数应该围绕构建这三个部分进行：

w.Header().Set(...) // 设置响应头
w.WriteHeader(...)  // 设置响应状态码
w.Write(...)        // 写入响应体

对于这三个函数，顺序是非常重要的，因为一旦调用 WriteHeader 或 Write 后响应头通常就已经被发送（go 会自动发送 200 OK）。

[!note] 响应头 HTTP 响应头是一组键值形式的元数据，用于描述响应，而不是响应的实际内容。

例如：
Content-Type: application/json
Content-Length: 15
Cache-Control: no-cache
Allow: GET
其中 Content-Type 的含义是告诉客户端响应体应该按什么格式解析。

第一个完整的例子

所以对于实现一个简单的 GET /healthz 监听响应程序，我们可以这样书写代码：

package main

import (
	"log"
	"net/http"
)

func healthz(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		w.WriteHeader(http.StatusMethodNotAllowed)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write([]byte(`{"status":"ok"}`))
}

func main() {
	http.HandleFunc("/healthz", healthz)
	log.Println("Server start ok")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		log.Fatal(err)
		return
	}
}

理解 HTTP Method

在动手实现 CRUD 之前，需要先建立对 HTTP Method 的准确认识，理解 Method 与 CRUD 的映射关系。

Method 是什么

先建立最基础的模型。从语义层面看，一个 HTTP Request 可以先关注：

Method + Path + Header + Body

其中 Method 可以先理解为客户端希望对目标资源执行的动作。例如 GET /targets/1 表示请求读取 /targets/1 所标识的资源。

HTTP Method 和 CRUD 有常见对应关系，但两者并非严格等价。例如 POST 也可以表示提交任务或触发处理，并不一定创建资源。

GET        → Read
POST       → Create（常见用法之一）
PUT/PATCH  → Update
DELETE     → Delete

GET

GET 表示获取资源的当前表示。例如 GET /targets 通常读取 Target 集合，而 GET /targets/1 读取 ID 为 1 的单个 Target。

假设服务器中存在：

Target: 1
name = "google"
address = "https://google.com"

Target: 2
name = "github"
address = "https://github.com"

请求 GET /targets 时，服务器可以返回 JSON 数组：

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "id": 1,
    "name": "google",
    "address": "https://google.com"
  },
  {
    "id": 2,
    "name": "github",
    "address": "https://github.com"
  }
]

如果请求 GET /targets/1，则只返回 ID 为 1 的资源；资源不存在时通常返回 404 Not Found。

GET 是安全且幂等的方法："安全"表示客户端请求的目标不是修改服务器状态；"幂等"表示多次相同请求的预期效果与一次相同。

POST

POST 表示客户端向目标资源提交数据，请服务器按照该资源的语义进行处理。在本项目中，它用于向集合创建一个新 Target：

POST /targets
Content-Type: application/json

{
  "name": "google",
  "address": "https://google.com"
}

创建成功后通常返回 201 Created 和创建后的资源，也可以通过 Location 响应头告诉客户端新资源的 URI。

设计资源风格的 API 时，一般使用 POST /targets，而不是 POST /createTarget，因为 Method 已经表达了操作语义。不过这是一种常见 API 设计方式，不是 HTTP 协议强制规定。

POST 通常不是幂等方法：重复发送同一个创建请求，可能创建多个不同资源。

PUT

PUT 通常表示：

用客户端提供的完整表示替换目标资源的当前表示。

例如客户端发送：

PUT /targets/1
Content-Type: application/json

{
  "name": "google",
  "address": "https://google.com"
}

则服务器中的资源会被完整替换为：

{
  "id": 1,
  "name": "google",
  "address": "https://google.com"
}

PUT 是幂等方法：多次发送相同 PUT 请求，其预期服务器状态与发送一次相同。在 sentinel-go 当前约定中，更新不存在的 ID 返回 404 Not Found；HTTP 标准也允许某些 API 使用 PUT 创建指定 URI 的资源，因此具体行为需要在接口契约中写清楚。

PATCH

PATCH 也表示更新。与 PUT 的完整替换不同，PATCH 请求体描述要应用到资源的一组局部修改，因此通常只提供需要变化的字段。

例如客户端发送：

PATCH /targets/1
Content-Type: application/json

{
  "name": "bing"
}

更新后的资源可能是：

{
  "id": 1,
  "name": "bing",
  "address": "https://google.com"
}

PUT 和 PATCH 成功后可以返回更新后的资源和 200 OK，也可以在不返回正文时使用 204 No Content；具体选择应保持一致并写入接口契约。PATCH 不保证天然幂等，其幂等性取决于补丁格式和操作语义。

DELETE

DELETE 用于删除目标资源。当客户端发送 DELETE /targets/{id} 时，就是请求删除该 ID 对应的 Target；成功且不返回正文时通常使用 204 No Content，资源不存在时通常返回 404 Not Found。

DELETE 是幂等方法。这里的"幂等"指多次相同请求的预期服务器状态与执行一次相同，而不是要求每次响应状态码完全相同；第一次删除可能返回 204，再次删除可能返回 404。

安全性与幂等性速查

Method	安全	幂等	项目中的常见用途
GET	是	是	查询 Target
POST	否	通常否	创建 Target
PUT	否	是	完整替换 Target
PATCH	否	不一定	局部修改 Target
DELETE	否	是	删除 Target

动手实现 CRUD

理解了请求链路和 Method 语义之后，就可以在 net/http 的基础上，根据 HTTP Method 对资源执行创建、读取、更新和删除操作。在开始 CRUD 之前，需要先理解路由器的选择。

自定义路由器

最简单的例子使用了 http.ListenAndServe(":8080", nil)。其中第二个参数为 nil 时，服务器会使用全局的 http.DefaultServeMux。我们也可以显式创建并传入自己的路由器：

mux := http.NewServeMux()
mux.HandleFunc("/healthz", healthz)
http.ListenAndServe(":8080", mux)

这样，请求链会更加清晰：

客户端
  │
  │ GET /healthz
  ↓
HTTP Server（读取并解析请求）
  │
  ↓
mux（根据 Method + Path 匹配 Handler）
  │
  ↓
healthz
  │
  ↓
ResponseWriter
  │
  ↓
客户端

这里需要注意：如果路由通过 http.HandleFunc 注册，它会进入 DefaultServeMux；如果服务器最终使用的是新建的 mux，请求就匹配不到这些路由。因此，注册路由和启动服务器必须使用同一个 ServeMux。

Go 1.22 之后的方法路由

在一些旧教程中，我们会看到下面的写法：

mux.HandleFunc("/targets", targetsHandler)

func targetsHandler(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		// 查询
	case http.MethodPost:
		// 创建
	default:
		// 405
	}
}

从 Go 1.22 开始，标准库 ServeMux 的 pattern 支持 Method 和路径通配符，因此可以写成：

mux.HandleFunc("GET /targets", listTarget)
mux.HandleFunc("POST /targets", addTarget)

mux.HandleFunc("GET /targets/{id}", getTarget)
mux.HandleFunc("PUT /targets/{id}", updateTarget)
mux.HandleFunc("DELETE /targets/{id}", deleteTarget)

本文示例统一使用复数资源路径 /targets，而当前 sentinel-go 代码仍使用 /target。两种路径都能被路由器处理，但同一个项目应统一代码、README、测试和笔记中的接口契约，避免调用时混用。

HTTP Server 负责读取并解析原始请求，ServeMux 接收解析后的 *http.Request，再根据 Method、Host 和 Path 选择 Handler。换句话说，ServeMux 是请求多路复用器，而不是 HTTP 报文解析器。

{id} 只匹配一个路径段，可以通过 r.PathValue("id") 读取，返回值类型是 string。另外，"GET /targets/{id}" 也会匹配 HEAD 请求；当 Path 能匹配、Method 不能匹配时，ServeMux 会返回 405 Method Not Allowed。

处理路径参数：ID 问题

r.PathValue() 返回字符串。如果资源 ID 使用整数表示，就需要进行转换，并将转换失败视为客户端请求错误：

id, err := strconv.Atoi(r.PathValue("id"))
if err != nil {
	http.Error(w, "invalid id", http.StatusBadRequest)
	return
}

PathValue 读取的是 ServeMux 已匹配路径通配符的值。例如路由 pattern 为 "GET /targets/{id}" 时，请求 /targets/12 得到的 id 是字符串 "12"。如果请求没有经过包含该通配符的路由匹配，结果会是空字符串。

生成 ID 时不能简单使用 len(targets) + 1，因为删除中间元素后，新 ID 可能与仍然存在的 ID 冲突。当前练习可以维护独立的递增计数器；并发处理请求时，计数器和 map 必须放在同一套同步策略下保护。

如何返回 JSON

可以使用标准库中的 json.NewEncoder(w).Encode(value) 构造 JSON 响应，并通过结构体标签控制字段名称：

type Target struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
	Addr string `json:"address"`
}

写入正文前需要设置响应头和状态码：

w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(value); err != nil {
	// 记录错误；响应提交后不能再修改状态码。
}

第一次调用 WriteHeader，或者第一次写入响应体时，HTTP 状态码就会提交。状态码提交后再调用 http.Error，不能把已经发送的 200 改成 500。如果必须保证"编码失败时返回 500"，可以先用 json.Marshal 在内存中完成编码，成功后再写响应头和正文。

当需要返回多个资源时，可以先构造切片，再编码成 JSON 数组：

list := make([]Target, 0, len(targets))
for _, target := range targets {
	list = append(list, target)
}

if err := json.NewEncoder(w).Encode(list); err != nil {
	// 记录错误
}

如何解析 JSON

请求体可以通过 Decoder 解析到结构体中：

var req TargetRequest

if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
	http.Error(w, "invalid json", http.StatusBadRequest)
	return
}

这里需要传入 &req，因为 Decoder 必须修改调用方持有的变量，才能把解析结果写入结构体字段。解析和校验通过后，再构造资源并写入服务器的存储：

target := Target{
	ID:   nextID,
	Name: req.Name,
	Addr: req.Addr,
}

targets[nextID] = target

拒绝未知字段与业务校验

如果希望拒绝目标结构体中不存在的 JSON 字段，可以使用：

var req TargetRequest
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()

if err := decoder.Decode(&req); err != nil {
	http.Error(w, "invalid json", http.StatusBadRequest)
	return
}

DisallowUnknownFields 只负责拒绝未知字段，不会判断缺失字段、空字符串或地址是否合法；这些业务规则仍需单独校验。Decode 本身会报告 JSON 语法错误和类型不匹配。

if req.Name == "" || req.Addr == "" {
	http.Error(w, "name and address are required", http.StatusBadRequest)
	return
}

只调用一次 Decode 还可能接受正文末尾的第二个 JSON 值。需要严格限制请求正文时，可以在第一次解析成功后再次解析并确认得到 io.EOF，同时根据服务边界考虑限制请求体大小。

map 中的结构体是值副本

当 targets 的类型是 map[int]Target 时，下面读取出的 target 是结构体副本：

target, ok := targets[id]

修改副本后必须显式写回：

target.Name = req.Name
target.Addr = req.Addr
targets[id] = target

否则 PUT 响应可能返回新值，但后续 GET 仍然读到旧值。

Handler 中不要调用 log.Fatal

非法 ID、非法 JSON 和资源不存在都只是一次请求的失败，不应终止整个服务器。log.Fatal 记录日志后会调用 os.Exit(1)，因此 Handler 应返回合适的 4xx；服务器内部错误一般记录日志并返回 500。

当前实现边界

当前 sentinel-go 使用内存 map 保存 Target，因此服务重启后数据会丢失。net/http 会并发处理请求，而普通 map 与自增 ID 计数器不能安全地被多个请求同时读写；后续需要引入互斥保护并使用 go test -race 验证。自动化测试、服务超时和优雅退出也尚未完成。

参考资料

接口

Sat, 04 Jul 2026 00:00:00 GMT

语法

我们使用 type [接口名称] interface{} 来声明一个接口

type Sayer interface {
	Say(messge string) error
}

当我们需要实现一个接口的继承的时候，我们可以直接实现这个接口里的方法

type Dog struct {
    name string
}

func (dog *Dog)Say(messge string) error{
	fmt.println(dog.name + "说：" + messge)
	return nil
}

// 在实现的时候我们可以
var sa Sayer
d := &Dog{"name"}
sa = d
sa.Say()       //接口可以调用d的方法了，此时我们实现了接口

工程约束

命名约定：
- 单一方法接口：以er结尾，例如Reader,Writer
- 不要预先定义：接口应该由使用者定义，而不是生产者定义
接口设计：越小越好
- Go语言鼓励组合小接口而不是去创建一个庞大的接口
接受接口，返回结构体
- 在设计一个函数的时候，应该尽量接受接口，以提高函数的通用性
- 函数应该返回具体的结构体

接口能干什么

下面我们用一个简单的需求展现interface的功能

需求描述：多渠道告警系统

我们的任务是编写一个告警小程序。这个程序需要支持多种通知方式（如邮件、短信），并且要能够轻松扩展新的通知方式（比如以后要加一个“钉钉告警”），而不需要修改核心的业务逻辑代码。

接口定义:
定义一个名为 Notifier 的接口，它必须包含一个方法：Notify(message string) error
具体实现
实现两个结构体，并让它们都满足 Notifier 接口：

EmailNotifier: 结构体里包含一个 Address 字段。调用 Notify 时，打印：“向邮件地址 [xxx] 发送了消息：[内容]”。
SMSNotifier: 结构体里包含一个 PhoneNumber 字段。调用 Notify 时，打印：“向手机号 [xxx] 发送了短信：[内容]”。

核心业务逻辑（关键点）
编写一个函数 SendAlerts：
- 参数：接受一个 Notifier 接口的切片（[]Notifier）和一条消息字符串。
- 功能：循环遍历切片，调用每个元素的 Notify 方法。

在 main 函数中：

创建一个包含一个 EmailNotifier 和一个 SMSNotifier 的切片。
调用 SendAlerts 函数，把这个切片传进去。
进阶思考:

如果现在想增加一个 WeChatNotifier，你是否需要修改 SendAlerts 函数的代码？

参考：

package main

import (
	"fmt"
)

type Notifier interface {
	Notify(message string) error
}

type EmailNotifier struct {
	Address string
}

type SMSNotifier struct {
	Phonenumber string
}

func (emi *EmailNotifier) Notify(message string) error {
	fmt.Println("向邮件地址" + emi.Address + "发送了信息:" + message)
	return nil
}

func (sms *SMSNotifier) Notify(message string) error {
	fmt.Println("向手机号" + sms.Phonenumber + "发送了信息" + message)
	return nil
}

func SendAlerts(notify []Notifier) error {
	for _, n := range notify {
		n.Notify("Testmessage")
	}
	return nil
}

// 新增WeChatNotifier
type WeChatNotifier struct {
	WechatID string
}

func (wec *WeChatNotifier) Notify(message string) error {
	fmt.Println("向微信号:" + wec.WechatID + "推送：" + message)
	return nil
}

func main() {
	nois := []Notifier{&EmailNotifier{"test1"}, &SMSNotifier{"test2"}}
	SendAlerts(nois)
	nois = append(nois, &WeChatNotifier{"test3"})
	SendAlerts(nois)
}

你可见过红色的飘带游荡在星空

Sun, 26 Apr 2026 00:00:00 GMT

[!important]+
本评价可能含有《挽救计划》的剧透，请有打算观影的朋友酌情观看

Chapter1:出发

有一名朋友,最近沉迷星际拓荒，在相关视频下刷到《挽救计划》这部影片，便萌生了一探究竟的想法，顺便带上了我。作为一部小说改编的超长科幻电影:spoiler[长达整整2个半小时],在影院亮灯的一瞬间，我的感受是 "酣畅淋漓"，在我的评价中已经达到佳作水准。这部片子最好的有点如果让我总结的话，就是 "逻辑完整且剧情正常"。

客观来说《挽救计划》的制作水准绝对是出色的，虽然没有很多《流浪地球》中注重"大场面"来进行宏大叙事的视觉冲击，但是其将很多细节打磨的非常好，以一种 "纪实叙事" 将信息反馈给幕前的观众，而这一特性在与外星人从接触到熟悉这一段中将会体现的更加充分。

Chapter2:第一次接触

"第一次接触" 是一个专有名词，表示人类对地外智慧生命的第一次接触与交流。在有 "外星人" 这样题材的科幻中，将 "外星人" 与 "人类" 的关系塑造清楚且逻辑正常其实是一个非常困难的事情。很容易陷入一种 "人类中心主义" 的陷阱之中，而这个片子巧妙的将两个文明的第一次接触从两个个体的接触展开。

这其实是一个高明的写法,描述两个文明中"文明的冲突"比两个个体的"个体的冲突"会难写的多，因为在个人中可以放大个体所展现的 "非理性" 的部分:spoiler[爱与和平有什么不好的!]将猜疑与揣测转化为一种纯粹的处于个体内心的"冲动感",文明会去需要考虑牺牲自己是不是值得的但是个体并不会，在这部片子中主角和洛基直接先后的救赎就是这样的体现。空旷的太空与孤身一人:spoiler[(一石头?)]的孤独感让两个个体成为互相支撑他人的存在，而这种属于个体的强烈情感不仅可以让导演更好的发挥出属于 "文明的温暖面" 的叙事，也能让我们更好体会这部片子的主旨："在面对未知的文明时我们是否有勇气拯救对面"

Chapter3:红色的飘带

评价科幻作品，我们通常观察其三个内核:逻辑,想象力,深层人文属性。就像"喜剧的内核是悲剧一般",科幻作品最终讨论的 "在面对一个可能存在的情形中，人(人类)会怎么做"。《星际穿越》让我们体会到了人类在面对绝对未知时候展现的勇气，《流浪地球》告诉我们人类团结的力量能有多大。这部剧则从人的视角出发，传达了"文明的温暖面"这样的主旨。

逻辑叙事方面，本作的插叙做的非常优秀。:spoiler[我一开始只是以为是纯粹的插叙，后面仔细一想才发现这其实是主角被"绑"到飞船后逐渐找回记忆的过程]同时，在科学方面的严谨性做的也不错,将噬星体从被发现到捕获利用，到主角在天仓五中收集捕食者等描述，逻辑是合理的且具有想象力的。

Chapter4:星河中的文明

其实仔细一想，这篇文章特意提及噬星体已经感染了几乎所有文明，这就和人类共同面对一个困难一样。全宇宙的文明都共同面对一个问题。所以到这样的一个层面，洛基说的那句 "拯救地球，拯救波江星"其实就是两个人的抉择，而这样的抉择从两人:spoiler[外星人也是人(]互相选择为对方牺牲的决定而体现。这正是一种善良与温暖，而就是这样的善良与温暖同时救了地球和波江星。

环境塑造方面，这部片子可谓是致敬了一堆片，而且其对于太空遥远距离的 "孤独感" 的氛围塑造也是不得不品的，而真是这种出色的孤独塑造，让两个在太空流浪的文明个体有了交流和依靠。

总的来说，这是一部质量上乘的，故事逻辑清晰完整且能让我一下子全神贯注投入到其故事中的优秀科幻作品，好评喵

基础知识

Sat, 28 Mar 2026 00:00:00 GMT

容器

试想一下，假如你正在和团队一起开发一个Web应用，主要有三个组件构成—— 一个 React 前端，一个 Python API 和一个 PostgreSQL 数据库，如果你想在这个项目上工作，你就必须安装 Node,Python 和 PostgreSQL

那我们如何确保自己和团队中的其他开发人员使用相同的版本？或者如何保证我们的 CI/CD 系统相同？或者生产环境中使用的版本相同?

这个时候我们就可以选择进入容器

什么是容器？简单来说，容器是为我们的应用程序的每个组件提供的隔离进程。每个组件——前端 React 应用程序、Python API 引擎和数据库——都在其自己的独立环境中运行，与您机器上的其他所有内容完全隔离。

一般来说容器具有以下特点:

自包含 : 每个容器都有其所运行需要的一切，不依赖主机的任何依赖
隔离：每个容器都是在隔离状态运行的，降低其对主机和其他容器的影响
独立: 每个容器都是独立管理的，删除一个容器不会影响其他容器
便携: 容器可以在任何地方运行，在开发机器和服务器等地方都是以相同方式工作

容器实践

我们的实践都默认在 CLI 环境下进行，这是为了更好的适应 Shell环境和服务器环境，当然如果一个工作可以在vscode远程链接上使用，我们也会讲。~~绝对不是imicola是用wsl的~~

启动第一个容器

打开命令行终端输入:

docker run -d -p 8080:80 docker/welcome-to-docker

[!tip]- 命令的解析
在这个命令中， docker run 是一个复合命令，其结合了 docker create 和 docker start 两个命令，同时一些参数表示如下：

-d 表示后台运行，不加这个参数会让docker输出日志而不是返回终端环境，此时如果按下 <Ctrl-c> 会导致容器终止

-p 8080:80 表示将本机8080端口映射到docker的80端口上

此时我们便完成了第一个容器的启动

查看正在运行的容器

要想查看正在运行的容器，我们可以使用 docker ps 命令，这个命令会输出所有正在运行的容器

我们将会看到类似的输出：

 CONTAINER ID   IMAGE                      COMMAND                  CREATED          STATUS          PORTS                      NAMES
 a1f7a4bb3a27   docker/welcome-to-docker   "/docker-entrypoint."   11 seconds ago   Up 11 seconds   0.0.0.0:8080->80/tcp       gracious_keldysh

这个容器运行的是一个简单的web服务器，当我们处理更复杂的项目的时候，我们会在不同的容器中运行不同的部分

访问前端

当我们启动容器之后，我们便将容器的一个端口暴露在我们的机器上，对于这个容器，我们可以用 http://localhost:8080 来访问

关闭容器

要关闭一个容器，我们可以使用 docker stop 命令，这个命令需要使用容器的ID，使用 docker ps 获取即可

[!Tip]+
当我们通过ID引用容器的时候，不需要提供完整的ID，只需要提供足够多的ID部分保证其唯一性即可，如我们可以使用 docker stop a1f 来停止我们的示例容器

镜像

如果说容器是一个隔离的进程，那它会从什么地方获取文件和配置，又如何共享这些环境？这便是容器镜像发挥作用的地方

容器镜像是一个标准化的软件包，包含了运行容器所需的一切文件、运行库和配置

镜像有两个重要的原则:

镜像是不可变的，一旦镜像被创建就无法修改它，你只能创建新的镜像或者在原有的镜像上添加更改
容器镜像由层组成，每一层代表一组文件系统更改，这些更改可以添加，删除，或者修改文件

这两个原则让我们可以扩展现有镜像或在现有镜像基础上添加内容。例如，我们正在构建一个 Python 应用程序，我们可以从 Python 镜像开始，并添加额外的层来安装您应用程序的依赖项并添加代码。这使我们可以专注于我们的应用程序，而不是 Python 本身。

镜像实践

搜索并下载镜像

我们可以用 docker search 命令搜索镜像:

docker search docker/welcome-to-docker

此时我们将看到类似的输出，这个输出向我们展示有关 Docker Hub 上可用相关镜像的信息

然后，我们可以使用 docker pull 拉取镜像，就如同使用 git clone 拉取仓库一般

了解镜像

使用 docker image ls 命令可以列出我们已经下载的镜像，使用 docker image history 命令可以列出镜像的层

我们会看到类似的输出：

IMAGE          CREATED        CREATED BY                                      SIZE      COMMENT
648f93a1ba7d   4 months ago   COPY /app/build /usr/share/nginx/html # buil...  1.6MB     buildkit.dockerfile.v0
<missing>      5 months ago   /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon...  0B
<missing>      5 months ago   /bin/sh -c #(nop)  STOPSIGNAL SIGQUIT           0B
<missing>      5 months ago   /bin/sh -c #(nop)  EXPOSE 80                    0B
<missing>      5 months ago   /bin/sh -c #(nop)  ENTRYPOINT ["/docker-entr...  0B
<missing>      5 months ago   /bin/sh -c #(nop) COPY file:9e3b2b63db9f8fc7...  4.62kB
<missing>      5 months ago   /bin/sh -c #(nop) COPY file:57846632accc8975...  3.02kB
<missing>      5 months ago   /bin/sh -c #(nop) COPY file:3b1b9915b7dd898a...  298B
<missing>      5 months ago   /bin/sh -c #(nop) COPY file:caec368f5a54f70a...  2.12kB
<missing>      5 months ago   /bin/sh -c #(nop) COPY file:01e75c6dd0ce317d...  1.62kB
<missing>      5 months ago   /bin/sh -c set -x     && addgroup -g 101 -S ...  9.7MB
<missing>      5 months ago   /bin/sh -c #(nop)  ENV PKG_RELEASE=1            0B
<missing>      5 months ago   /bin/sh -c #(nop)  ENV NGINX_VERSION=1.25.3     0B
<missing>      5 months ago   /bin/sh -c #(nop)  LABEL maintainer=NGINX Do...  0B
<missing>      5 months ago   /bin/sh -c #(nop)  CMD ["/bin/sh"]              0B
<missing>      5 months ago   /bin/sh -c #(nop) ADD file:ff3112828967e8004...  7.66MB

此输出显示所有层,他们的大小以及创建该层的命令

而对于构建镜像的知识我们会在后面的文章中详细介绍

注册表与镜像仓库

既然我们已经知道了什么是容器以及镜像，简洁的说镜像就如同git仓库项目一般，那么既然是一个项目，必然有其存储的地方

我们当然可以在我们的计算机中存储我们的容器镜像，但是如果我们需要分享或者需要协同工作呢？此时我们就需要镜像仓库

镜像仓库是存储和共享容器的集中位置，其可以是私有的或公共的。Docker Hub 就是一个任何人都可以使用的公共仓库:spoiler[我看未必]，也是默认的仓库

除了Docker Hub以外，我们也有许多的容器注册表，包括

注册表实践

:spoiler[对于中国用户而言,下载 Docker 注册表镜像和上传是有些限制的,在之前可以使用镜像来解决这些问题，但是目前来看镜像站已经被wall完了,所以需要下面内容默认你会使用魔法]

注册Docker Hub账户并且创建仓库

如果你还没有创建账户，请前往 Docker Hub 页面注册一个新的 Docker 账户。

之后选择创建仓库 (Create a Repository)并按需求填入名称，描述与可访问性

[!tip]- 关于可访问性
docker 对个人用户相当慷慨，为免费用户提供无限的公开仓库创建权限和单个私人仓库创建权限，对于个人开发者，这完全足够，如果你需要更多的私人仓库，可以选择升级Plan或者使用GHCR

创建并推送镜像

创建镜像一般会编写Dockerfile，这个知识我们将在后面的内容中了解

如果你是Docker Desktop用户，你需要先登录Docker Desktop然后按下面的方法来推送镜像

运行以下命令来构建 Docker 镜像，将 YOUR_DOCKER_USERNAME 替换为您的用户名，将 DOCKER-NAME 改为你的容器名称

docker build -t <YOUR_DOCKER_USERNAME>/<DOCKER-NAME> .

运行docker image ls命令以列出新创建的 Docker 镜像
通过运行docker run -d -p 8080:8080 <YOUR_DOCKER_USERNAME>/<DOCKER-NAME> 命令启动容器以测试镜像
使用 docker tag 命令来标记 Docker 镜像。Docker 标签允许您对镜像进行标记和版本控制

docker tag <YOUR_DOCKER_USERNAME>/<DOCKER-NAME> <YOUR_DOCKER_USERNAME>/<DOCKER-NAME>:1.0

最后，通过使用 docker push 命令将新构建的镜像推送到您的 Docker Hub 仓库：

docker push <YOUR_DOCKER_USERNAME>/<DOCKER-NAME>:1.0

这样你就成功将一个镜像推送到了Docker Hub中

[!note]- 那对于不使用docker desktop的用户呢？

我们一般会使用 Docker Engine自带的命令行工具来完成镜像的推送与拉取

首先你需要登录仓库，使用 docker login 命令登录docker hub，如果是私有仓库 docker login <仓库地址>

之后也是使用 docker tag 为镜像打标签，再使用 docker push 命令推送镜像即可

简单利用 Docker 进行开发

Fri, 27 Mar 2026 00:00:00 GMT

说明

本项目跑在 WSL(Arch) 下,使用 docker desktop，有一些踩坑指北

现在我们已经安装了 Docker Desktop，准备好进行一些应用程序开发了。具体来说，您将执行以下操作：

克隆并启动一个开发项目
对后端和前端进行更改
立即查看更改

启动项目

在开始使用之前，我们需要先将项目配置文件克隆到本地文件

git clone https://github.com/docker/getting-started-todo-app

随后进入项目文件夹

cd getting-started-todo-app

随后我们便可以使用 docker compose 启动开发环境

docker compose watch

[!note]+ 什么是 docker compose ?

Docker Compose 是一个用于定义和运行多容器 Docker 应用程序的工具。它使用 YAML 文件来配置应用程序的服务、网络和卷等，然后通过一个简单的命令就可以启动整个应用程序的所有服务。

简单来说 docker compose 就是将多个容器编排在一起从而实现一个服务的配置工具，通过docker compose我们可以原子化每一个容器，从而不会将所有环境都配置在一个大容器中

然后就是神秘的地方了

docker会先拉取 traefik,mysql,phpmyadmin这三个镜像，如果你没有较好的网络，可能会导致拉取失败，从小
随后是进行 building，会下载一些包比如 npm 等，然后进行 npm install构建整个容器
但是最后在启动后端和 traefik 的时候会返回报错

此时我们使用 docker ps -a 指令列出所有的容器

显然， traefik 和 backend 启动失败，imicola这里猜测是因为前面的端口不可用，导致无法后端无法链接到前端，同时没办法通过网络映射到主机端口，导致返回错误，从而中断了容器启动

~~真是复杂的网络环境啊~~

询问 ai 后得知在这个报错中

Error response from daemon: ports are not available: exposing port TCP 0.0.0.0:80 -> 127.0.0.1:0: /forwards/expose returned unexpected status: 500

docker desktop尝试将容器内的端口映射到 Window 主机的80端口中

显然window的80端口是非常繁忙的，通过netstat -ano | findstr :80我们可以看到是那个进程在占用这个端口

 netstat -ano | findstr :80
  TCP    0.0.0.0:80             0.0.0.0:0              LISTENING       4
  TCP    10.56.96.140:47703     111.31.2.195:8081      TIME_WAIT       0
  TCP    10.56.96.140:50794     120.233.22.121:8080    ESTABLISHED     20960
  TCP    10.56.96.140:58477     1.95.20.105:80         ESTABLISHED     22052
  TCP    127.0.0.1:8080         0.0.0.0:0              LISTENING       14976
  TCP    [::]:80                [::]:0                 LISTENING       4

很好，是PID 4，那大概率是一个系统进程了，查命令管理器发现，PID4对应的是 System , ~~那谁也抢不过你了~~

那我们就让端口避让，通过修改 compose.yaml 配置可以修改对应端口,在44行处找到proxy post配置，将其修改尝试

  proxy:
	image: traefik:v3.6
    command: --providers.docker
    ports:
      - 8081:80  #将80:80
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

接着在命令行中输入 docker compose watch,这次构建顺利，此时服务已经启动，在浏览器中输入 http://localhost:8081/ 即可访问服务

可以看到这是一个 TODO List 的Web应用，接下来我们了解如何直接编辑项目获得实时的开发预览

环境里有什么

这个 docker 项目里都有什么呢？从高层次来看，有一些容器，每一个容器都为这个web程序提供特定的功能

React前端: 对应 getting-started-todo-app-client-1，一个运行 React 开发服务器的 Node 容器，使用 Vite 构建
Node后端: 对应 getting-started-todo-app-backend-1，后端提供一个API，用于检索，创建，和删除代办事项的能力
MySQL数据库：对应 getting-started-todo-app-mysql-1 用于存储项目列表的数据库
phpMyAdmin: 对应 getting-started-todo-app-phpmyadmin-1 一个用于与数据库交互的基于Web的界面，可通过 http://db.localhost访问
Traefik 代理: 对应 getting-started-todo-app-proxy-1 一个应用代理程序，可以将请求路由到正确的服务，它将所有针对 localhost/api/* 的请求发送到后端，将针对 localhost/* 的请求发送到前端，然后将针对 db.localhost 的请求发送到 phpMyAdmin。这使得可以使用主机一个端口访问所有应用程序（而不是为每个服务使用不同的端口）。

在这个环境中，作为开发者的我们无需安装或配置任何服务，无需填充数据库架构，无需配置数据库凭据，也无需其他操作。我们只需要 Docker Desktop。其余的一切都会自动运行。(难说)

对应用进行更改

使用 docker 进行开发也能获得如同原生开发一般即时观测的效果，我们只需要和往常一样修改项目中的内容即可，下面是一些例子

后端 - 更改问候语

页面顶部的问候语通过 /api/greeting 进行填充，目前它总是只返回 "Hello world",如果想改变它，我们可以在 backend/src/routes/getGreeting.js文件中修改这个js文件顶部的 const 变量，当然我们也可以将其变化为一个数组吗，然后随机调用

const GREETING = [
    "Hello world",
    "喵喵喵",
    "Edit with docker",
];

module.exports = async (req, res) => {
    res.send({
        greeting: GREETING[Math.floor(Math.random() * GREETING.length)],
    });
};

刷新界面即可看到，已经更新

![[Pasted image 20260327181221.png]]

前端 - 界面美化

我觉得这个界面不好看怎么办？让ai进行美化！(~~或者自己干~~)

前端的文件位于 /client 中，按正常思路对前端进行美化，刷新页面观察效果即可

~~依旧ai审美~~

关闭docker

对于 docker compose,我们可以使用 docker compose down 将容器彻底删除 (不会删除镜像)，这是推荐的方式，可以释放容器的空间，因为保留了镜像，下次使用的时候直接构建就可以了

如果不想删除容器，方便下次快速启动，我们可以使用 docker compose stop 命令

Docker 入门

Thu, 26 Mar 2026 00:00:00 GMT

我觉得任何人在学习docker之前都应该去看看官方文档

什么是Docker？

在官方文档中这么写到:

Docker 是一个用于开发、交付和运行应用程序的开放平台。Docker 使您能够将应用程序与基础设施分离，从而快速交付软件。借助 Docker，您可以像管理应用程序一样管理基础设施。通过利用 Docker 的代码交付、测试和部署方法，您可以显著缩短编写代码与在生产环境中运行代码之间的延迟。

实际上，Docker是容器的一种，其核心思路是将应用程序及其所需的全部环境（代码、运行库、配置文件等）打包成一个独立的单元，这样就实现了应用程序在任何地方都能以相同的方式运行

这样有什么好处呢？

Docker解决的是 “项目在我的电脑上能跑，但是在服务器/你的电脑上就跑不了” 的问题

Docker 架构

Docker使用客户端-服务器架构，Docker 客户端与 Docker 守护进程通信，后者负责构建、运行和分发 Docker 容器的主要工作

Docker 客户端和守护进程可以运行在同一个系统上，或者我们可以将 Docker 客户端连接到远程 Docker 守护进程

Docker 守护进程

Docker 守护进程 (dockerd) 监听 Docker API 请求并管理 Docker 对象，例如镜像、容器、网络和卷。守护进程还可以与其他守护进程通信以管理 Docker 服务。

Docker 客户端

Docker 客户端是用户与Docker交互的主要方式，当我们使用诸如 docker run 等命令的时候，客户端会将这些命令发送给 dockerd,然后由 dockerd 执行这些命令

Docker 对象

当我们使用 Docker 的时候，会创建或使用镜像，容器，网络，卷，插件等其他对象，这一小节简述了一些对象

镜像

镜像是一个只读模板，包含用于创建 Docker 容器的指令。通常来说，镜像基于另一个镜像，并且进行一些额外的定制。例如，我们可以构建一个基于 Ubuntu 镜像的镜像，但安装了 Apache Web 服务器和我们的应用程序，以及我们应用程序所需要的详细配置

我们可能会创建自己的镜像，或者只使用他人创建并发布在注册表中的镜像。要构建自己的镜像，可以创建一个 Dockerfile，使用简单的语法定义创建和运行镜像所需的步骤。Dockerfile 中的每条指令都会在镜像中创建一个层。当我们修改 Dockerfile 并重新构建镜像时，只有那些发生变化的层会被重新构建。这也是镜像相比于其他虚拟化技术更加轻量、小巧和快速的部分原因。

容器

容器是 镜像的可运行实例。我们可以使用 Docker CLI 或者 API 进行创建，启动，停止，移动和删除容器。我们同样可以将容器连接到一个或多个网络，为其挂载存储，甚至根据当前状态为其创建新的镜像

默认情况下，容器与其他容器及其主机相对隔离。当然，我们可以控制容器的网络、存储或其他底层子系统与其他容器或主机的隔离程度。

容器由其镜像以及在创建或启动时提供的任何配置选项定义。当容器被移除时，未存储在持久存储中的任何状态更改都会消失。

计算机网络-自顶向下方法导读

Sun, 22 Mar 2026 00:00:00 GMT

计算机网络

《计算机网络:自顶向下》这本书是一本学习计算机网络的好书，和国内常见的教材不一样的地方，这本书从顶层开始向下进行剖析解析，从应用层到物理链路，而不是上来就从底层开始讲述，这篇文章主要是对整本书的一个基础导读，帮助我们梳理清楚这个快800多页大厚本究竟在说些什么

我们将按照章节对这本书进行拆分，由于原书对很多特别细致的知识点都有提及(~~甚至讲了双绞铜线这种~~)，所以我们不会完全列举出来，而是将我认为比较重要的知识点与名词列出来

chapter-1 Introduction

结构

第一章可以看作是整本书的缩影，其结构是由内向外的，其主要讲述了下面的这部分内容：

定义基础: 从「具体构成」(软件和硬件) 和「提供的服务」(基础设施) 两个角度定义了什么是互联网,并且引出 [[协议]] 的概念
网络边缘: 介绍了我们日常生活中的设备，以及他们是如何通过「接入网」接入互联网的
网络核心: 深入网络内部，探讨负责转发数据的路由器和交换机网络。重点对比了「分组交换」与「电路交换」，并解释了互联网是由众多 ISP（网络服务提供商）组成的 网络的网络
性能指标：这一段内容讲解了数据在网络之间传输的时候为什么会产生延迟，为什么会丢包？以及什么因素决定了网络的吞吐量
协议分层与封装: 这一节内容讲述为了应对网络的复杂性，网络被划分为 5 个层次:应用层、传输层、网络层、链路层、物理层 (这也是本书的结构),并且介绍了数据在不同的层之间如何进行封装
网络安全威胁: 简单的讲述了一些互联网面临的常见的攻击手段

知识点与名词

第一章中我们需要理解的知识点将被列在下面:

协议: 原书1.1.3
- 协议(protocol)定义了在两个或多个通信实体之间交换的报文的格式和顺序，以及报文的发送/接收或其他事件所采取的操作
端系统/主机：原书1.2
- 位于网络边缘的设备：客户端 通常是发起通信的设备，服务端 是等待联系的设备
分组交换：原书1.3.1
- 互联网传输数据的核心方式: 发送方将长报文分割成小的数据块「即分组或数据包」，这些分组在网络中独立传输并且贡献链路宽带
存储转发: 原书1.3.1
- 多数分组交换机（路由器）采用的机制。路由器必须接收到完整的数据包后，才能开始向输出链路转发它的第一个比特
四种网络延迟: 原书1.4.1
- 处理延迟
  - 检查包头，决定将数据包导向何处所需要的时间
- 排队延迟
  - 数据包在路由器输出队列中等待传输的时间
- 传输延迟
  - 将数据包的所有比特推向链路所需的时间
- 传播延迟
  - 比特在物理媒介中从一个路由器传播到下一个路由器所需的时间（取决于物理距离和光速）
丢包：原书1.4.2
- 由于路由器的队列容量是有限的，当到达的流量过大导致队列满了时，新到达的包或队列中的包就会被丢弃
吞吐量与瓶颈链路：原书1.4.4
- 吞吐量是目标端接收数据的速率。在一条端到端的路径中，吞吐量往往受限于那条传输速率最慢的链路（即瓶颈链路）
协议栈与封装 原书1.5.2
- 数据从应用层向下传递时，每一层都会给它加上自己的「头部信息（Header）」，这就是封装。就像把信件装进快递信封，再装入集装箱一样

Chapter-2 Application Layer

本章主要讲述的内容是在网络站点等这些「上层方面」的应用层上网络的一些知识

结构

应用层原理基础: (2.1)
- 首先定义了网络应用是如何构建的，以及它们是如何通过“套接字（Socket）”这个门与底层的传输层（TCP/UDP）交互的
四大核心应用协议：(2.2 - 2.5)
- Web与HTTP(2.2):现代互联网的基石
- 电子邮件(2.3): SMTP、IMAP等
- DNS 目录服务(2.4): 将人类可读的域名转换为机器可读的IP
- P2P 文件分发(2.5): 探讨去中心化的架构(如bt种子)
内容分发网络 CDN: (2.6)
- 为了解决海量视频/内容带来的带宽和延迟瓶颈，引出了 CDN
Socket 编程Lab: (2.7)
- 最后，回归代码，展示如何用 TCP 和 UDP 的 Socket API 写出真实的客户端与服务端

知识点

网络应用架构和Socket接口
- 客户端-服务端架构 (Client-Server) ：服务器拥有固定的IP地址且始终在线，由客户端主动向服务器发起请求
- 套接字 (Socket) ：进程通过网络发送和接受消息的软件接口
- TCP 与 UDP 的选择 : TCP提供面向链接，可靠的数据传输和拥塞控制；UDP 提供无连接，不可靠但无延迟的传输
Web 与 HTTP
- 无状态 (Stateless) 与 Cookies：HTTP 服务器本身不保存客户端的状态。为了识别用户身份（如登录状态），引入了 Cookie 机制，在 HTTP 请求和响应的 Header 中传递状态
- 持久连接 (Persistent Connections)：HTTP/1.1 默认使用持久连接，允许在同一个 TCP 连接上发送多个 HTTP 请求和响应，避免了每次请求都消耗一次 TCP 握手的 RTT（往返时间）
- Web 缓存 (代理服务器/Proxy) : Web 缓存代表原始服务器满足 HTTP 请求，极大降低了客户端的响应延迟和机构接入链路的带宽压力
- HTTP/2 与队头阻塞 (HOL Blocking) ：在 HTTP/1.1 中，如果一个大对象（如大视频）排在队列前面，会阻塞后面小对象的传输（队头阻塞）。HTTP/2 通过将消息分割成小帧 (Frames) 并在单个 TCP 连接上交错传输，解决了这个问题
DNS
- 核心功能: 将人类易读的主机名转换为32位的IP地址
- 分布式层次数据库: DNS 不是一台集中式服务器，而是由根 DNS 服务器 (Root)、顶级域 DNS 服务器 (TLD) 和权威 DNS 服务器 (Authoritative) 组成的层级结构
- DNS 缓存：为了减少延迟，DNS 广泛使用缓存技术。本地 DNS 服务器可以缓存它收到的任何解析结果，极大地减少了查询流量
视频流与CDN内容分发网络
- DASH ：客户端根据当前网络带宽动态选择请求不同清晰度（比特率）的视频块
- CDN ：为了避免单点故障和跨大洲传输的高延迟，CDN 在全球部署服务器集群
- DNS 重定向 ： CDN 利用 DNS 机制来拦截用户的请求，并将请求智能地重定向到距离用户最近或负载最低的 CDN 缓存节点

一个简单实例

[!NOTE]
我们来设想一个场景:
当我们在浏览器中输入 www.bilibili.com 来访问B站并且播放视频，这些组件会这样进行工作:

DNS介入: 浏览器首先需要知道 bilibili 网页服务器的 IP。它调用 DNS 发起查询

CDN和DNS进行联动: Bilibili 不会返回单一的IP，其DNS服务器会利用 DNS 重定向技术，根据当前发起请求的主机地理位置，返回距离我们最近的CDN节点的IP地址

TCP 握手与 HTTP 请求：浏览器拿到 IP 后，通过 Socket API 发起 TCP 三次握手，然后发送 HTTP GET 请求

Cookie 维持状态：HTTP 请求头中带有 Cookie，让 Bilibili 知道你已经登录，并且推荐你喜欢的视频

DASH 动态流媒体：当你开始播放时，视频播放器使用 DASH 协议，基于你当前的网络状况，不断通过 HTTP 请求不同画质的视频分片

Chapter 3 Transport Layer

第三章的主要层级是传输层,其主要逻辑是:

从抽象服务模型到通用的可靠性理论,再到TCP/UDP实现,最后探讨网络拥塞和现代协议演进

这一章会学很多的传输协议,比如 TCP,UDP 等,属于是比较硬核的一章,可能需要花费更多的时间来吃透

结构

传输层服务与多路复用 (3.1 - 3.2)
- 网络层只负责把数据送到"主机",而传输层负责将数据分发给主机上具体的"应用进程"(通过端口号实现多路复用/分解)
无连接传输 UDP (3.3)
- 一种"裸奔"的协议,仅提供多路复用和简单的错误检测,不保证可靠性,但延迟极低
可靠数据传输原理 RDT (3.4)
- 这是一个纯理论推导章节.探讨在一个会丢包,会出错的底层网络上,如何通过确认(ACK),定时器,序列号和重传机制,一步步构建出绝对可靠的传输通道
面向链接的传输 TCP (3.5)
- 理论落地.详细讲解 TCP 的报文结构,三次握手/四次挥手,RTT (往返时间) 估算,以及如何通过接收窗口(rwnd)实现流量控制
拥塞控制原理与 TCP 拥塞控制 (3.6-3.7)
- 探讨网络拥堵的代价.重点解析 TCP 如何通过拥塞窗口(cwnd)慢启动,拥塞避免(AIMD),快速恢复等算法
传输层的演进 QUIC (3.8)
- 介绍运行在 UDP 之上的现代协议 QUIC,它解决了 TCP 队头阻塞问题,并实现了更快的安全连接建立(HTTP/3 的基础)

知识点

端口与多路分解
- UDP 的 2 元组:UDP 套接字仅由 (目的 IP,目的端口) 标识
- TCP 的 4 元组:TCP 套接字由 (源 IP,源端口,目的 IP,目的端口) 唯一标识
  - 逻辑链接:为什么你的单台 Nginx Web 服务器在 80 端口上能同时处理成千上万个客户端连接? 因为每个客户端的源 IP 或源端口不同,TCP 依靠这 4 元组将流量精准分解到不同的线程/套接字中.这也解释了为什么客户端压测时会遇到"端口耗尽(Port Exhaustion)"问题
TCP 连接管理
- 三次握手 (3-way Handshake):客户端发送 SYN,服务端回复 SYNACK,客户端回复 ACK
- 四次挥手 & TIME_WAIT 状态:连接关闭时,主动关闭方会进入 TIME_WAIT 状态(通常持续 1-2 分钟),以确保最后一个 ACK 能到达对方
- SYN 泛洪攻击与 SYN Cookies:恶意客户端只发 SYN 不发最后一步的 ACK,耗尽服务器资源.通过 SYN Cookies 技术,服务器初始不分配资源,而是用哈希值作为初始序列号,从而防御此类攻击
核心机制:序列号,ACK 与快速重传
- 累积确认 (Cumulative ACK):TCP 的 ACK 数字表示"我正在等待接收的下一个字节号",这意味着该数字之前的所有字节都已成功接收
- 快速重传 (Fast Retransmit):如果网络丢包,发送方通常要等一个漫长的超时时间(Timeout)才能重传.但如果发送方连续收到 3 个冗余 ACK(即同一个 ACK 数字出现 4 次),它会立即判定后续报文已丢失,在超时发生前就执行重传,极大降低了延迟
"流量控制" 和 "拥塞控制"
- 这是最容易混淆的两个概念,它们共同决定了 TCP 实际上能发多快:发送速率受限于 min(rwnd, cwnd)
- 流量控制 (Flow Control - 保护接收方):接收方在 TCP 头部通过 rwnd (Receive Window) 字段告诉发送方自己接收缓冲区还有多少可用空间,防止发送方发得太快把接收方"淹没"
- 拥塞控制 (Congestion Control - 保护网络):发送方自己维护一个 cwnd (Congestion Window),根据探测到的网络拥堵情况(丢包)来调整发送速度
- 慢启动 (Slow Start):连接刚建立时,cwnd 呈指数级增长,以最快速度探明网络可用带宽
- 拥塞避免 (AIMD):到达阈值后,转为线性增加(每 RTT 增加 1个 MSS);一旦发生丢包(如收到 3 个冗余 ACK),窗口直接减半
- TCP CUBIC:现代操作系统常用的拥塞控制算法.丢包后,它能根据三次函数曲线,更快地将发送速率恢复到丢包前的水平
QUIC
- 传统 HTTPS 需要先经历 TCP 握手,再经历 TLS(加密)握手,延迟高;且 TCP 保证严格按序到达,会产生"队头阻塞(HOL blocking)". QUIC 跑在 UDP 上,在应用层实现了独立的可靠性和拥塞控制(类似 TCP NewReno),允许多个数据流多路复用,丢包只影响单个流

Chapter 4 & 5 The Network Layer

第四章和第五章两章构成一个完整的「网络层」框架，本书将网络层拆分成为了两个独立的章节「数据平面」和「控制平面」，而这种分离正好也是现代网络框架的一个核心概念

Chapter 4 Data Plane

第四章聚焦单台路由器的局部动作，即当一个数据包达到路由器输入链路的时候，如何将其移动到正确的链路，这些动作通常都在纳秒之间完成且由硬件实现

结构

路由器内部结构 (4.2)：
- 深入了解输入/输出端口的处理，内部交换结构（如内存，总线，交叉开关结构）以及排队和调度机制
IP 协议与寻址 (4.3):
- 详细讲解了 IPv4 和 IPv6 数据报的格式。我们需要重点掌握IP编址、子网划分与无类别域间路由（CIDR）,以及网络地址转换（NAT）
通用转发与 SDN 基础 (4.4):
- 探讨了基于 OpenFlow 的“匹配加动作（Match-plus-action）”模型。这打破了传统仅基于目标IP转发的限制，是现代软件定义网络（SDN）的数据平面基础

Chapter 5 Control Plane

在这一章中，我们主要聚焦于网络范围内的全局逻辑，即如何协调各台路由器，计算出数据包从源主机到目标主机的端到端路径

结构

路由算法理论
- 我们会在这章中学习两个经典算法，需要全局网络信息的链路状态算法（LS，例如 Dijkstra 算法），以及分布式迭代的距离向量算法（DV，例如 Bellman-Ford 算法）
互联网路由协议
- OSPF: 互联网中最常用的自治系统（AS）内部路由协议，基于链路状态算法
- BGP：治系统之间的路由协议。BGP 是将互联网中成千上万个 ISP 粘合在一起的“胶水”
SDN 控制平面
- 绍了逻辑上集中的控制器（如 OpenDaylight 或 ONOS）如何维护全局网络状态，并通过协议（如 OpenFlow）计算并下发流表给底层的交换机/路由器
网络运维与管理协议
- 包括用于网络诊断的 ICMP（Ping 和 Traceroute 工具就是基于此协议实现的），以及用于设备监控与自动化配置的传统 SNMP 和现代数据建模语言 NETCONF/YANG

知识点

对于两个章节来说，第四章的核心思想是解决单个路由器如何处理和转发数据包的问题，第五章的核心思想是网络范围内的逻辑协调，负责计算转发表并且管理网络设备

Data Plane

转发与路由的核心区别
- 转发是数据平面的局部动作，发生在纳秒级，负责将到达路由器输入链路的数据包转移到正确的输出链路；路由是控制平面的网络全局过程，发生在秒级，负责计算数据包从源到目的地的端到端路径
路由器内部架构
- 包含输入端口（执行查找与物理/链路层功能）、交换结构（如通过内存、总线或交叉开关移动数据包）、输出端口以及路由处理器
最长前缀匹配
- 在传统基于目的地的转发中，路由器在转发表中寻找与数据包目的IP地址匹配的最长前缀，以此决定输出接口
IPv4 编址与 CIDR (无类别域间路由)
- 理解IP地址的层次结构、子网（Subnet）的划分，以及形式如 a.b.c.d/x 的网络前缀掩码配置
DHCP (动态主机配置协议)
- 设备通过即插即用的方式自动获取IP地址、子网掩码、默认网关和DNS服务器地址的机制
NAT (网络地址转换)
- 允许内部网络使用私有IP地址，通过在NAT转换表中映射IP地址和端口号，解决IPv4地址短缺问题并隐藏内部网络结构
广义转发与 SDN (软件定义网络) 数据平面
- 基于 OpenFlow 等协议的 "匹配加动作 (Match-plus-action)" 模型。数据面不仅能基于目的IP转发，还能同时匹配链路层、网络层和传输层的多个头部字段，并执行转发、丢弃（防火墙）、重写头部（NAT）或负载均衡等丰富的动作

Control Plane

两种控制平面架构
- 每路由器控制：
  - 传统网络中，每个路由器内部运行路由算法，与网络中其他路由器的路由组件相互通信来计算转发表
- 逻辑集中式控制:
  - SDN采用的方法，由一个远程的集中式控制器计算并向各个路由器（或分组交换机）下发流表
两大经典路由算法
- 链路状态算法 (LS, Link-State)
- 距离向量算法 (DV, Distance-Vector)
AS 内部路由 (OSPF)
- 开放最短路径优先（Open Shortest Path First），是自治系统（AS）内部广泛使用的路由协议，基于链路状态算法，支持区域划分和安全认证
AS 之间路由 (BGP)
- 边界网关协议（Border Gateway Protocol），是连接互联网中成千上万个ISP的“粘合剂”。BGP 基于 CIDR 前缀进行路由通告，其核心特点是高度依赖策略 (Policy)（如通过 AS-PATH 和 NEXT-HOP 属性决定流量控制和商业关系），而不是单纯追求最短或最快路径
ICMP (互联网控制报文协议)
- 用于主机和路由器之间传递网络层错误信息。SRE 常用的 Ping 和 Traceroute 工具均直接基于 ICMP 实现

简单的端口查询Lab

Sat, 14 Mar 2026 00:00:00 GMT

这是一个简单的Lab,目前用于测试新功能canvas

🔒 爱国公司CloseAI食用指南

Fri, 13 Mar 2026 00:00:00 GMT

🔒 本文已加密保护，请访问博客网站输入密码阅读全文。

🔒 继续在21世纪活下去

Fri, 13 Mar 2026 00:00:00 GMT

🔒 本文已加密保护，请访问博客网站输入密码阅读全文。

文件读写

Sat, 07 Mar 2026 00:00:00 GMT

文件读写

小文件

如果你能确定你读取的文件或者你写入的数据量，那么你可以使用 os 提供的 ReadFile 和 WriteFile 函数

// 文件读入
data,err := os.ReadFile("example.txt")
if err != nil{
	log.Fatal(err)
}
fmt.Println(string(data))

// 文件写出
content := []byte("Hello Go")
err := os.WriteFile("out.txt",content,0644)
if err != nil{
	log.Fatal(err)
}

逐行或按块处理

使用 bufio.Scanner 逐行读取

file , err := os.Open("large_file.txt")
if err != nil{
	log.Fatal(err)
}
defer file.Close() //注意关闭文件

scanner := bufio.NewScanner(file)
for scanner.Scan(){
	string s = scanner.Text()
	// 处理
}
if err := scanner.Err(); err != nil{
	log.Fatal(err)
}

文件的写入操作

如果你需要对文件进行更精细的控制（比如追加内容），需要使用 os.OpenFile。

追加内容到文件

// O_APPEND: 追加模式, O_CREATE: 如果不存在则创建, O_WRONLY: 只写模式
file, err := os.OpenFile("log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
    log.Fatal(err)
}
defer file.Close()

if _, err := file.WriteString("New log entry\n"); err != nil {
    log.Fatal(err)
}

使用 `bufio.Writer` 提高性能

在频繁进行小量写入时，使用缓冲区可以显著减少系统调用，提升性能。

writer := bufio.NewWriter(file)
writer.WriteString("Buffered string")
writer.Flush() // 必须调用 Flush 确保数据从缓冲区写入磁盘

进程、前后台、服务与例行性任务

Sat, 21 Feb 2026 00:00:00 GMT

进程

进程是运行中的程序的实例，是操作系统进行资源分配和调度的基本单位，当然这些更加底层的事情我们会留到操作系统这门课的时候进行讲解

我们在window上可以通过任务管理器很轻松的看见运行在电脑上的进程，在linux中我们也有观察系统进程的工具

Linux进程管理器

很多人会推荐 htop 这一个工具来进行进程管理，这个工具是top命令的改良，可以很方便的查看当前所有的进程以及系统CPU，内存占用等信息，而且其占用低

我更推荐 btop 工具，在功能性上其完全不输 htop，只需要付出一点点的占用代价就能获得更加直观与全面的分析，同时更加美观~~(颜值即实用)~~，可以通过 btop 界面上展示的快捷键快速对进程等系统资源进行操作与分析

~~真是美美又观观啊~~

ps

ps（process status）是常用的输出进程状态的工具，直接调用 ps 仅显示本终端中运行的相关进程，如果要显示所有进程，对应命令是 ps aux

一点小技巧，你可以使用 ps aux --sort=-%cpu来对ps的输出进行CPU占用排序，这在cpu高占用排查和编写脚本的时候会很有用

进程标识符

对于操作系统中的每一个进程，都有一个唯一标识来区分这些进程，这个唯一表示即 进程标识符PID,当我们想挂起，继续，或者终止程序的时候，我们都需要使用 PID 作为索引

[!tip]
当我们观察按PID进行排序的界面时候，我们很难不注意到 PID 的排序总是遵循一种规律，比如 PID1 是 systemd ，PID2 是 init-systemd
这里其实涉及 PID 分配机制，其有两个特性

顺序性: 只要计数器没达到上限，新进程的PID总是比之前的大，系统内部维护一个计数器，每创建一个进程，这个计数器就+1并且将其分配给这个进程

回绕: Linux系统中有一个 pid_max，通常是32768或更高，当计数器达到这个上限后，系统便会回到这个低位寻找已经被注销的空闲PID进行重新分配

有时候我们会注意到PID之间的跳跃，如从 PID8 到 PID42,然后又马上到180+

这种情况有两个可能

瞬时进程：在系统启动的时候会启动很多的脚本或者初始化任务，它们执行完后就消失了，但是其消耗了中间的 PID 计数

多线程/子进程: 在一些现代软件和~~天才工程师~~的程序中，会fork出大量的子进程，这些进程会占用 PID

进程优先级与状态

其实你知道吗？一个CPU核心一次只能执行一个进程，而现代民用CPU一般就20多个核心，而电脑中进程动辄上百个，为了让这些进程看起来是在「同时」执行的，操作系统会用非常快的速度在这些进程中来回切换，而这也就引入了进程优先级和进程状态的概念

优先级与 nice 值

对于很多的程序来说，其各个占用的资源不同，所以需要一个设定来指定程序的优先级。在 htop和top中有两个与优先级有关的值 Priority(PRI) 和 nice(NI)

Nice值越高代表一个进程对其他进程越 nice(友好)，其对应的优先级也就越低。nice值最高为 19，最低为-20。通常来说程序的默认nice值应该都是0。我们可以通过 htop，btop等来调整进程的nice值

用户可以使用 nice 命令在运行程序时指定优先级，而 renice 命令则可以重新指定优先级。当然，若想调低 nice 值，还需要 sudo（毕竟不能随便就把自己的优先级设置得更高，不然对其他的用户不公平）。

进程状态

进程不是一直在系统中运行的，进程可以被简单的分为3类

运行态(Running): 即正在运行底层程序
就绪态(Ready)：可以运行但是正在排队等待的程序
阻塞态(Blocked)：正在等待其他资源(网络，磁盘等)而无法立刻开始运行的程序

而在linux中，系统对于进程的分类会更加复杂一些，下面表显示了进程状态

状态	缩写表示	说明
Running	R	正在运行/可以立刻运行
Sleeping	S	可以被中断的睡眠
Disk Sleep	D	不可被中断的睡眠
Traced / Stopped	T	被跟踪/被挂起的进程
Zombie	Z	僵尸进程

用户进程控制

控制进程的前提是与进程进行通话，由于进程之间不会共享内存空间，所以就无法直接发送信息，于是就需要操作系统的链接，因此，信号机制就产生了

信号

信号是 Unix 系列系统中进程之间相互通信的一种机制。发送信号的 Linux 命令叫作 kill。被称作 "kill" 的原因是：早期信号的作用就是关闭（杀死）进程。

下面是一些常用的信号：

信号名称	编号	默认动作	详细含义
HUP	1	终止	Hangup:最初用于拨号终端断开。现在常用于通知守护进程重新加载配置文件（不重启进程）。
INT	2	终止	Interrupt:来自键盘的中断信号，通常是用户按下了 Ctrl+C。
QUIT	3	终止+Core	Quit:类似 INT，但由 Ctrl+\| 触发，并且会生成 Core Dump 文件用于调试。
KILL	9	终止	Kill：强制杀死进程。该信号不能被捕获、阻塞或忽略，进程无法在退出前进行清理。
TERM	15	终止	Terminate:优雅退出。这是 `kill` 命令默认发送的信号，它告诉进程“请你保存数据并关闭”，进程可以捕获并处理。
TSTP	20	暂停	Terminal stop:用户通过 Ctrl+Z 发送的暂停信号，可以被捕获。
CONT	18	继续	Continue。让被暂停(STOP/TSTP)的进程恢复运行。由 `fg` 或 `bg`发出

前后台切换

一般来说，我们创建的进程默认都是跑在前台，如果想要在程序运行的时候还可以做其他事情而不是看着程序跑，那我们就需要将程序放到后台来跑

在shell中输入命令的时候，我们可以在命令结尾添加&来告诉命令在后台运行

10:42:03 with imicola in ~ is 📦 None …
➜ ./test &

如果想让前台的程序切换到后台，我们需要按下Ctrl + Z发送 SIGTSTP 让进程挂起，再输入 jobs 命令，就可以看到被挂起的程序以及其代号

终止进程

终止前端进程

对于运行在前端的程序，我们只需要在终端界面按下 Ctrl + c 就会向程序发送 SIGINT 信号告诉程序需要退出

xtop中发送信号

在所有类top命令中，一般都会有发送信号的方式，比如 top 和 htop 命令中，我们通过按下 k 键来向进程发送信号，在 btop 命令中，kill键将对选择的进程发送 SIGTERM 退出信号，s可以选择发送的信号

kill

如前所述，Linux 上最常用的发送信号的程序就是 kill

[imicola@LAPTOP-1R3FN2QL ~]$ kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 2) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
3) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
4) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
5) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
6) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
7) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
8) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
9) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
10) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
11) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
12) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
13) SIGRTMAX-1  64) SIGRTMAX

[!Tip]
不同shell的kill命令略有不同，如zsh中

11:49:27 with imicola in ~ is 📦 None …
➜ kill -l
HUP INT QUIT ILL TRAP IOT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM TERM STKFLT CHLD CONT STOP TSTP TTIN TTOU URG XCPU XFSZ VTALRM PROF WINCH POLL PWR SYS

如果不加任何参数，只有 PID，kill 命令将自动使用 15（SIGTERM）作为信号参数。

脱离终端

如果你之前使用过 SSH 连接到远程服务器执行任务，那么你会发现，在shell中执行的任务会在SSH断开后被关闭，因为SSH断联时会向进程发送 SIGHUB 信号

nohub

nohub,字面含义，就是「不要被SIGHUB影响」

在命令之前输入 nohub 即可,运行时候的输出会被重定向到 nohub.out中，也可以通过重定向自定义输出文件

$ nohub ping localhost

tmux

在之前的 [[命令行环境#终端多路复用|终端多路复用]] 中我们就有稍微了解过一些 tmux，我们其实可以将 tmux 看作一个脱离目前终端但是前端在终端上的终端模拟器，其解决了会话保持和窗口复用的问题，在这里我们不过多赘述

服务

在操作系统（OS）的语境下，「服务」（Service）通常指那些在后台运行、不直接与用户交互，但为系统或其他应用程序提供特定功能的程序或进程。

守护进程

当进程启动时脱离终端会话，避免因为终端的关闭而消失，这类一直默默工作与后台的进程被称为 守护进程

服务管理

目前绝大多数Linux发行版的init方案都是 systemd，其管理系统服务的命令是 systemctl

在管理服务前，我们需要清楚有什么服务，使用 systemctl status可以观察系统服务运行状态

对于服务的启动，终止，重载命令等，可以参考下面的说明：

$ tldr systemctl
systemctl
Control the systemd system and service manager.

    - List failed units:  # 列出运行失败的服务
    systemctl --failed

    - Start/Stop/Restart/Reload a service:  # 开启/关闭/重启/重载服务。Reload 代表重载配置文件而不重启进程。
    systemctl start/stop/restart/reload {{unit}}

    - Show the status of a unit:  # 显示服务状态
    systemctl status {{unit}}

    - Enable/Disable a unit to be started on bootup:  # 设置（Enable）/取消（Disable）服务开机自启
    systemctl enable/disable {{unit}}

    - Mask/Unmask a unit, prevent it to be started on bootup:  # 阻止/取消阻止服务被 enable
    systemctl mask/unmask {{unit}}

    - Reload systemd, scanning for new or changed units:  # 重载 systemd，需要在创建或修改服务文件后执行
    systemctl daemon-reload

自定义服务

如果我想将一个基于web的应用作为局域网的web服务以便在其他设备上访问，那我们应该如何将其注册为 systemd服务呢？

[!note]
要想实现服务的注册，我们可以通过编写 .service 文件来实现，下面以 Jupyter Notebook 来示例
[Unit]
Description=Jupyter Notebook    # 该服务的简要描述

[Service]
PIDFile=/run/jupyter.pid        # 用来存放 PID 的文件
ExecStart=/usr/local/bin/jupyter-notebook --allow-root
                                # 使用绝对路径标明的命令及命令行参数
WorkingDirectory=/root          # 服务启动时的工作目录
Restart=always                  # 重启模式，这里是无论因何退出都重启
RestartSec=10                   # 退出后多少秒重启

[Install]
WantedBy=multi-user.target      # 依赖目标，这里指进入多用户模式后再启动该服务
然后，将写好的配置文件放入 /etc/systemd/system/jupyter.service中，运行 systemctl daemon-reload，就可以使用 systemctl 来管理这个服务了

例行性任务

所谓的例行性任务，指的是基于时间的一次或者多次的周期性任务，在linux中实现定时任务工作的程序主要有 [[at]] 和 [[crontab]]

目录访问与文件操作

Mon, 09 Feb 2026 00:00:00 GMT

操作文件与目录

在 linux 中进行操作文件与目录是使用 Linux 的最基础的一个功能，在linux中不同于Windows和macOS下在图形界面简单拖拽文件就能完成文件移动，在linux中我们更加倾向于在命令行中完成操作

查看当前命令行目录

要想进行文件管理和操作，我们得先知道我们在哪？一般而言，shell环境会显示我们当前的位置，这点我们在 [[Shell#在shell中导航|在shell中导航]] 这一块中有提到，同时，使用pwd命令也可以获取我们目前shell所在的目录

查看文件夹内容

我们主要通过 ls 命令来查看当前文件夹下的内容，ls默认会隐藏目录下 . 开头的文件和文件夹，如果需要将其全部输出可以使用 ls -a 来查看所有文件

有一些项目里还会提供树状图结构的目录，这其实可以通过tree命令生成，在使用前需要安装

[!tip]
eza是ls的现代化代替品，输出会更加好看
sudo pacman -S eza
eza几乎可以代替 ls 作为文件目录输出索引，传入的参数和 ls 也几乎一致，故我们可以用
alias ls=eza
来直接将 ls 替换为 eza

查看文件内容

cat

当我们需要在终端中查看一个文件的内容的时候我们只需要 cat <文件名> 即可

[!note] 为什么叫cat
当然和猫咪没有关系，cat 这里是 concatenate（连接）的缩写，因为 cat 工具实际的功能是连接多个文件，然后输出。但是当只有一个文件的时候，cat 就会直接输出这个文件，所以 cat 最常见的用途就是输出单个文件。

less

less 和 cat 的区别在于， cat 会一次性将所有内容打印到终端中并退出，而less一次只显示一页并且支持向前后滚动和搜索功能，通常情况下less会比cat方便许多

实际上在Linux还有 more 和 most 两个和 less 类似的指令，但是流行程度不如 less

编辑文件内容

这部分内容可见[[编辑器(vim)]]

复制剪切文件和目录

这部分常用的指令是[[cp]]和[[mv]]

cp 命令用于对文件进行复制

# 将 源文件 复制到当前目录下，其名称为后一个参数
cp [OPT] <源文件名称> <新文件名称>
# 将 SOURCE 文件拷贝到 DIRECTORY 目录下，SOURCE 可以为不止一个文件 
cp [OPTION] SOURCE... DIRECTORY

mv的使用方法与cp类似，效果类似Windows下的剪切

# 将 源文件 剪切到当前目录下，其名称为后一个参数(其实就是重命名功能)
mv [OPT] <源文件名称> <新文件名称>
# 将 SOURCE 文件拷贝到 DIRECTORY 目录下，SOURCE 可以为不止一个文件 
mv [OPTION] SOURCE... DIRECTORY

删除文件

[!danger]
当你在终端使用 rm 命令时候，这个操作将是不可逆的，你将会永远失去你删除的文件，特别是在 root 权限和使用 -r 参数的时候

使用命令 rm

rm [OPT] <file>
# 删除文件file1.txt
rm file.txt
# 删除test目录下所有文件
rm -r test/
# 尝试强制删除 test1/、test2/、file1.txt 文件和目录。这些文件或者目录可能不存在、有写保护或者没有权限读写
rm -rf test1/ test2/ file1.txt

除非你的计算机存在特殊备份措施或恢复措施，否则 rm 进行的删除命令是无法还原的

[!Warning]
在使用 rm 删除的时候，请务必注意目录拼写
rm -rf /home/imicola/f # 删除f
rm -rf / home/imicola/f # 删除根目录下的所有内容和 home/imicola/f 及其中的文件

[!tip]

rm 指令之所以危险是因为其是不可逆的，我们可以使用更加现代化且安全的 trash-cli 来代替 rm 指令。这和在 Windows 下删除文件进入回收站的逻辑是一致的

创建文件

使用 touch 命令创建文件

touch file1 file2

touch命令的时间功能是修改文件的访问时间和修改时间，类似于摸了一下文件，使其访问和修改时间发生了变化

搜索文件和目录

# 在 PATH路径中根据 表达式 搜索文件
find [opt] PATH [表达式]

[!tip]
在当前目录中搜索名为 report.pdf 的wenj
find . -name 'report.pdf'
全盘搜索大于 1G 的文件
find / -size +1G

[!tip]
对于文件搜索，我们同样有更好用的代替，如果是对于搜索文件，可以尝试 fzf 进行交互式模糊搜索，如果是希望有格式有条件的筛选，可以选择 fd，更多有关这部分的内容可以看[[文件查询]]

统计文件或文件夹大小

du 命令可以实现文件和文件夹大小的统计，一般而言我们可以直接使用 du -sh 来显示目标文件的总大小，用 du -h -d 1 显示当前目录下的总大小

此外，使用 ncdu 可以用交互式的方式来显示文件和目录的大小，并会按文件大小排序

模式匹配

通配

shell的通配字符主要应用在文件路径的展开上,需要注意的是,通配不是[[正则表达式]],而是更简单的快速选择文件的符号

? 匹配一个字符
- 如 file?.txt匹配file1.txt,fileA.txt等
* 匹配任意字符
- 如 *.py 匹配所有 .py 结尾的文件
[] 匹配方括号中的任意一个字符
- 如 [abc].txt 匹配 a.txt,b.txt,c.txt
{} 列表生成,即扩展为逗号分隔的字符串列表
- 如 {test1,test2}.txt 会被扩展成 test1.txt test2.txt

Go语言下的pprof

Fri, 06 Feb 2026 00:00:00 GMT

对于go语言的pprf分析我们有两种情况，一个是针对长期开启的服务进行探测，还有一种是针对脚本进行分析

针对服务型

我们可以在代码中使用 net/http/pprof 包。你只需要在代码中匿名引入，它会自动在 8080（或其他你定义的）端口开启一个 /debug/pprof 路由。

// 在main函数中启动
go func() {
   http.ListenAndServe("localhost:6060", nil)
    }()

这样go会在6060端口下打开一个网页(~~虽然很简陋~~)，访问http://localhost:6060/debug/pprof/就可以看到这样一个的分析

脚本

对于脚本和一些简单go程序，会运行一段时间直接退出，这个时候就不适合打开端口监控了，我们可以直接在脚本中插入埋点

package main

import (
    "os"
    "runtime/pprof"
    "runtime"
    "log"
)

func main() {
    // --- CPU Profile ---
    cpuFile, err := os.Create("cpu.prof")
    if err != nil {
        log.Fatal(err)
    }
    pprof.StartCPUProfile(cpuFile)
    defer pprof.StopCPUProfile()

    // 运行你的脚本逻辑
    runScriptLogic()

    // --- Memory Profile ---
    memFile, err := os.Create("mem.prof")
    if err != nil {
        log.Fatal(err)
    }
    defer memFile.Close()
    
    // 显式运行一次 GC，确保内存数据准确
    runtime.GC() 
    if err := pprof.WriteHeapProfile(memFile); err != nil {
        log.Fatal(err)
    }
}

func runScriptLogic() {
    // 模拟耗时或内存密集操作
    sum := 0
    for i := 0; i < 1000000; i++ {
        sum += i
    }
}

这个时候我们运行结束后会发现目录下多了cpu.prof 和 mem.prof 文件，我们使用pprf就可以进行分析：

go tool pprof cpu.prof

更推荐的测试方法

如果我们需要测试的内容可以封装为一个函数，那么使用 Go 的测试工具链进行性能分析是最简单、最专业的做法，不需要在业务代码里写任何 pprof 代码

我们需要编写一个benchmark文件

package main

import "testing"

func BenchmarkMyTask(b *testing.B) {
    for i := 0; i < b.N; i++ {
        runScriptLogic() // 调用你要分析的函数
    }
}

然后通过 test 工具链对整个程序进行测试并生成分析

go test -bench . -cpuprofile cpu.prof -memprofile mem.prof

最后通过pprf进行分析

go tool pprof -http=:8080 cpu.prof // 在8080端口打开网页，需要安装Graphviz

Go语言语法

Wed, 04 Feb 2026 00:00:00 GMT

语言特性

less can be more

这是go语言的核心思想

在go语言中，没有继承，多态，甚至是类

在go的文档中说Go语言几乎和C/C++一样快~~实则不然~~

语法

变量定义

在go语言中，主要采用类型后置的命名方式：

var age int = 25 \\ 经典定义方式
var age = 25 \\ 自动推断，类似C++中 auto
age := 25 \\ 简短定义，等效上一条

在Golang中支持批量的定义

var(
	a string
	b int
	c bool
	d float32
)

我们需要注意Golang的命名规则，即首字母大写的命名在包外是可以访问的

输入输出流(CLI下)

在go语言中，我们有两种对输入输出流进行控制的语法，分别是 fmt 包和 bufio 包

[!tip]
这两个包没有绝对的谁好谁坏的区别，对于fmt包而言，其适合格式化,对于 bufio 来说则更加侧重于性能

`fmt`包的标准输入输出：

import (
	"fmt"
)

func main() {
	a := 114
	// 标准输出
	fmt.Print("hello go")       // 普通的打印
	fmt.Println("hello Gooooo") // 等效于在Print中加\n
	fmt.Printf("%d", a)         //  类似于C的printf
	// 标准输入
	fmt.Scan(&a) // 从标准输入中读取，注意需要传入地址
	var str string
	fmt.Scanln(&str)
	fmt.Println(a)
	fmt.Println(str)
}

`bufio`的输入输出

func f2() {
	// 标准读入
	reader := bufio.NewReader(os.Stdin) // 创建一个输入流,类似于Java
	var x int
	var str string
	fmt.Fscan(reader, &x) // 搭配Fscan进行读入
	fmt.Fscan(reader, &str)
	// 标准输出
	writer := bufio.NewWriter(os.Stdout) // 创建一个输出流
	fmt.Fprintln(writer, x)
	fmt.Fprintln(writer, str)
	writer.Flush() // 必须要刷新缓冲区否则可能不会显示输出
}

基本数据类型

Golang的语言更加明确的数字类型命名

在go语言中，有以下几种基本的数据类型:

整型
浮点型
复数
布尔
字符串

整型

在go语言中整型可以分为两大类,其后面的数字表示了其占用的二进制位

无符号	有符号
`uint8`	`int8`
`uint16`	`int16`
`uint32`	`int32`
`uint64`	`int64`

浮点型

go语言支持两种浮点型，float32 和 float64，不存在double

对于float32其范围大概为$3.4 \times 10^{38}$，float64的范围大约为$1.8 \times 10^{308}$,两个浮点数都有常量Math.MaxFloat32 && Math.MaxFloat64

复数

complex32 和 complex64
其中后缀数字表示实部和虚部的位数

布尔

在go语言中我们用 bool 对布尔值进行声明

在Go语言中，没有1/0对布尔值的隐式转换，在建立布尔值的时候只能使用true或者false

布尔型无法参与数值运算，也无法与其他类型进行转换。

字符串

在go语言中，使用字符串和使用原生数据类型是一样的。在Golang的字符串内部使用的是UTF-8编码，所以我们可以直接使用非ASCII字符

s1 := "hello"
s2 := "你好"

对于字符串而言有许多和其他语言一致的\转译字符

转义	含义
\r	回车符（返回行首）
\n	换行符（直接跳到下一行的同列位置）
\t	制表符
'	单引号
"	双引号
\|	反斜杠

在go语言中也内置了和python一样好用的多行字符串

要实现一个多行字符串时，我们需要使用 反引号 字符 `

s1 := `第一行
第二行
第三行
`

反引号中的换行被作为字符串中的换行，所有的转义符号均无效，文本会原样输出

字符串常用操作

Go语言的字符串是一个不可变字节序列，本身并不是一个类，但是Go提供了一些函数来处理字符串

查找与包含类：

功能	方法	说明
是否包含	`strings.Contains(s, substr)`	返回 `bool`，判断 `substr` 是否在 `s` 中
查找位置	`strings.Index(s, substr)`	返回子串第一次出现的索引，不存在返回 `-1`
最后位置	`strings.LastIndex(s, substr)`	返回子串最后一次出现的索引
前缀判断	`strings.HasPrefix(s, prefix)`	判断是否以某字符串开头
后缀判断	`strings.HasSuffix(s, suffix)`	判断是否以某字符串结尾
统计次数	`strings.Count(s, substr)`	计算子串在字符串中出现的次数

分割与合并：

在处理CSV或路径的时候会十分有用，主要有两个函数：

分割 Split : 将字符串切分成片

s := "abc,edf,ghi"
item := strings.Split(s, ",")
fmt.Println(item)
//output: [abc edf ghi]

合并: 将切片连接成字符串

sil := []string{"abc","def","ghi"}
s2 := strings.Join(sil, "-")
fmt.Println(s2)
//output: abc-def-ghi

字符

组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。字符用单引号（’）包裹起来

在string中有两种字符类型：

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
rune类型，代表一个 UTF-8字符。

实际上，rune 是一个int32

字符串的修改

因为go的字符串是一个不可变字符组，所以当我们需要修改字符串的时候需要我们将字符串变为rune[]或者byte[]，然后在最后的时候转化回去

func changeString() {
	s1 := "hello"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'H'
	fmt.Println(string(byteS1))

	s2 := "你好世界"
	runeS2 := []rune(s2)
	runeS2[0] = '不'
	fmt.Println(string(runeS2))
}

但需要注意的是，这种转化会带来内存上的分配和拷贝问题，会对性能有一些开销问题

类型转换

在Go语言中，只有强制类型转化，没有隐式类型转化，其语法为 T(表达式)，其中T表示要转化的类型

流程语句

在go语言中，流程语句的书写习惯会更加偏向Python，比如if语句无需括号扩起，for range语法等

if语句

在Go语言中if语句有这些特点:

可省略条件表达式括号。
持初始化语句，可定义代码块局部变量。
代码块左括号必须在条件表达式尾部。

func f7() {
	a := "喵"
	if  b := "喵"; a == b {
		fmt.Println("喵喵")
	}
}

循环

在Go语言中只有for循环，对于for循环有几种变体：

func f8() {
	s1 := []int{1, 2, 3, 4}
	// 传统意义下的循环
	for i := 0; i < 4; i++ {
		fmt.Print(s1[i])
		fmt.Print(" ")
	}
	// 代替while循环
	n := 4
	for n > 0 {
		n--
		fmt.Print(s1[n])
		fmt.Print(" ")
	}
	// range 循环
	for idx, v := range s1 {
		fmt.Println(v)
		/*
			range会遍历指定的切片
			需要注意的是，这里的v是在循环第一步就被拷贝了的
			所以对这个v进行修改不会改变s1中的元素
			如果需要修改可以使用idx进行修改
		*/
		if idx == 2 {
			s1[idx] = 1
		}
	}
	// range 次数循环
	for range 4 {
		fmt.Println("喵")
	}
	p := 5
	for range p*2 - 1 {
		fmt.Println("喵")
	}
	// 死循环
	for {
		fmt.Println("喵")
	}
}

数组与切片

在Go中，数组类似和传统意义上的数组一致，是一种定死底层内存的数据结构，对于切片而言，其可以说是一种可扩展容量的数组

数组

数组是具有固定长度且编号连续的数据序列，具有以下特点

固定长度:在声明的时候必须指定长度且不可更改
值类型：在 Go 中，数组是值类型。如果你把一个数组赋值给另一个数组，它是完全拷贝一份数据。
注意长度也是构成数组类型的一部分，[3]int 和 [4]int 是两种完全不同的类型

切片

在Go语言中，有一种和C++中vector类似的数据结构，切片的声明如下:

s := []int{0}

切片是对一个连续片段的引用，其本身并不储存任何数据，本质是一个很小的结构体，包含三个字段:

指针：指向底层数组中切片开始的位置
长度：切片当前包含的元素的个数
容量：从切片起始位置到底层数组末尾的元素个数

注意切片是引用的，当我们将一个切片赋值给另外一个变量的时候我们实际上传入的是引用，所以当我们修改其中一个的时候，另外一个也会变

切片的初始化

原始的切片声明没办法实现复杂的初始化，我们可以用make语法对切片进行初始化

func f5() {
	n := 3
	s1 := make([]int, n) 
	for idx := range s1 {
		s1[idx] = idx + 1
	}
	fmt.Println(s1)
}

我们利用make函数还可以进行类似C++中预先分配内存的操作

func f6() {
	n := 3
	s1 := make([]int, 0, 2*n)
	idx := 1
	for range n * 2 {
		s1 = append(s1, idx)
		idx++
	}
	fmt.Println(s1)
}

切片的复制

正如我们前面所说，如果我们直接将一个切片传入另外一个切片的时候，直接赋值的引用，要实现切片的赋值可以参考下面的两个语法

func f4() {
	s1 := []int{1, 2, 3}
	// 使用append在一个空的数组后直接追加之前的元素
	s2 := append([]int{}, s1...)
	// 使用copy函数
	s3 := make([]int, len(s1)) // 注意这里s3的长度需要大于等于s1
	copy(s3, s1)
	s3[0] = 2
	s2[0] = 114
	fmt.Println(s1, s2, s3)
}

map

Go语言的map通过make语法声明：

mp := make(map[int]string)
mp[5] = "喵"

我们需要注意的是map中的键并非有序的，这个map更类似C++中的unordered_map

在go语言中，map的声明格式为 map[KeyType]ValType

我们推荐使用make语法初始化

m := make(map[string]int)
m["age"] = 25

map的comma ok

在获取 map 的值时，如果键不存在，Go 会返回该类型的零值（如 int返回0）。为了区分“值为0”和“键不存在”，我们通常这样做：

val, ok := m["key"] 
if ok { 
	fmt.Println("找到值:", val) 
} else { 
	fmt.Println("键不存在") 
}

map的遍历

我们可以使用for range对map进行遍历，但是我们需要注意的是，对map进行遍历的时候输出的顺序是随机的

map的删除

我们可以用delete函数删除map的一个键值对,语法规则是delete(map,key)其中，map表示要删除键值对的map；key:表示要删除的键值对的键

结构体

和其他语言一样，在Go语言中，结构体是将多个不同的数据结构组合在一起的自定义类型

因为在Go语言中不存在Class,所以OOP类型的语法都是通过结构体进行的

声明

type User struct{
	ID     int
	name   string
	Email  string
}

对于结构体的实例化的方法有以下四种：

// 实例化方法
	// 1.直接实例化
	var u0 User
	// 2.结构化实例(推荐)
	u1 := User{id: 1, name: "喵", Email: "?"}
	// 3.指针化实例
	u2 := &User{} // 返回的是一个空结构体指针
	// 4. 使用new实例化
	u3 := new(User)

在Go语言中，结构体在内存中是连续分布的，这使得结构体的访问速度非常快，对CPU缓存是友好的

结构体标签

在创建结构体元素的时候，我们可以为结构体打上标签

type User struct {
	id    int    `json:"id"`
	name  string `json:"name"`
	Email string `json:"Email"`
}

这种标签可以通过标准库中的reflect在运行时被解析，用于序列化，数据库映射等

方法

与其他语言不同，Go语言中结构体的方法不能放在结构体内部，而是脱离于结构体之外的

它的语法是在 func 关键字后加一个接收者(Receiver)

类型	语法	能否修改结构体的值
值接受者	`func (u User) f()`	否	拷贝一份副本，适合只读操作
指针接受者	`func (u *User) f()`	是	推荐方式，效率高且能修改状态

func (u *User) SetName(newName string) {
    u.Name = newName
}

组合与嵌套（伪继承）

在Go语言中不支持类的继承，而是提倡通过 匿名嵌套 来实现继承

type Animal struct {
	Name string
}

func (a *Animal) Getname() {
	fmt.Println(a.Name)
}

type Dog struct {
	Animal  // 此时dog已经继承Animal的方法和成员
}

func main() {
	d := Dog{}
	d.Name = "狗"
	d.Getname()
}

这种继承方式被成为组合，在一个结构体里不止能有一个父类，可以有很多父类

type C struct{
	A
	B
}

函数

Go语言摒弃了常规函数的类继承负担，设计的非常纯粹

函数声明和语法

Go语言的函数定义使用 func 关键字，其特点是变量名在前，类型在后

func add(a int,b int) int{
	return a + b
}

// 如果有类型一致的可以简写
func add(a,b int) int{
	return a + b
}

多返回值

不同于C++或Java只能返回一个类型，Go语言原生支持返回多个值

常规返回:

func divide(a,b float64) (float64,error){
	if b == 0{
		return 0,errors.New("算术错误")
	}
	return a / b,nil
}

命名返回：我们可以为返回值命名，这些初始的命名会被初始化为0值

func getRectProps(width,height float64) (area, perimeter float64){
	area = weight*height
	perimeter = (weight+height)*2
	return     // 裸返回，自动返回开头写的两个变量
}

变长参数

如果我们不确定会传入多少个参数，可以使用 ... 语法,在函数内部，这个参数会被当成切片处理

func sum(nums ...int) int{
	tot := 0
	for _, n := range nums{
		tot += n
	}
	return tot
}

匿名函数和闭包

Go语言中支持匿名函数且这些函数可以作为闭包存在，即可以捕获并且记住其定义时所在作用域的变量

func f1() func() int {
	i := 0
	res := func() int {
		i++
		return i
	}
	return res
}

func main() {
	counter := f1()        // 获取一个闭包
	fmt.Println(counter()) // 输出: 1
	fmt.Println(counter()) // 输出: 2
	fmt.Println(counter()) // 输出: 3
}

在上面的代码中你可能注意到了我们给res和counter都赋值了函数，这代表在Go语言中函数是可以被作为变量赋值，作为参数传递和作为返回值的

异常处理

在Go语言中，没有类似 try-catch 语句的异常捕获机制，其错误不是被抛出的，而是被当作普通的变量返回的

在go中我们有两种放回错误的方式：

errors.New("message"):最基础的方式,每次调用都会创建一个全新的地址，即便错误信息一模一样，它们也不相等
fmt.Errorf("error is: %v", detail):用于格式化错误信息

Linux下进行开发

Wed, 04 Feb 2026 00:00:00 GMT

Linux开发环境

相比与 Windows，在Linux下进行开发有如下好处：

安装简单: 所有开发链在Linux中都可以通过一个命令实现，非常简单
配置简单: 大多数的Linux开发工具的配置都可以通过编写配置文件完成，而且可定制性高于Windows
管理简单：不用在忍受Windows下恐怖的环境配置和抽象的编译链接

这篇文章主要讲解三个方面的知识:开发软件，编译工具，工程工具

开发软件

代码编写工具与IDE

图形化Linux界面

如果你是图形化的Linux界面，你可以自行安装代码编写工具，目前主流工具都对主流发行版有支持，比如Visual Studio Code提供多种包，也可以通过软件仓库进行安装

同时JetBrains系列的软件也对Linux支持度也很高，你完全可以在官网中或者各个发行版的软件仓库中找到支持的版本并且下载

WSL

如果你使用的是WSL，即 Windows Subsystem for Linux,其实更建议使用 Windows 上的代码编写工具，通过SSH或者WSL链接来获得更好的体验，虽然现在WSL2也原生支持wslg用来匹配GUI，但是其优化程度不如Windows

对于Visual Studio Code，有原生链接wsl的工具，输入ctrl + shift + P后输入 链接到WSL 即可以链接

编译工具

我们在程序课上就学习过，要想让我们写的程序语言变为真正的可执行文件，还需要通过编译器的编译

在Windows中，一般会给一份打包好的安装程序或者编译好的程序压缩包，而使用编译器需要配置环境变量等一系列操作，如果有多个编译程序(多版本管理)的时候还可能会出现编译混乱的情况

在Linux中其实解决了很多这样的问题，下面我们通过介绍几个例子

C++环境

在 Windows 上，你可能需要下载几个 GB 的 Visual Studio，或者手动配置 MinGW 的 bin 路径。

Linux 的做法： 只需一行命令安装 build-essential（以 Ubuntu 为例），它会自动帮你装好 gcc、g++、make 以及标准库头文件。

sudo apt update && sudo apt install build-essential

便利点： 安装完即用，不需要去系统属性里手动编辑 PATH。所有的头文件都在 /usr/include，库文件在 /usr/lib，编译器永远能找到它们。

Python环境

Windows 中管理 3.8、3.10、3.12 等多个python版本是比较棘手的

Linux 的做法： 大多数 Linux 发行版自带 Python。如果你需要管理多个版本，pyenv 是神器：

# 安装特定版本
pyenv install 3.10.12
# 在当前文件夹切换版本（仅对当前目录有效，不影响系统）
pyenv local 3.10.12

便利点： “目录级”的版本控制。你可以让项目 A 用 Python 3.8，项目 B 用 3.12，进入文件夹后版本自动切换，完全不会出现 Windows 上那种 python 和 python3 命令打架的情况

Go环境

Go 语言虽然在 Windows 上也有安装包，但配置 GOPATH 和 GOROOT 曾是很多人的噩梦

Linux 的做法： 除了包管理器，Go 在 Linux 下通常只需解压到 /usr/local 即可。更方便的是使用 snap 或 asdf：

sudo snap install go --classic

便利点： Go 的交叉编译在 Linux 下表现极佳。由于 Linux 环境本身就是服务器的标准环境，你在 Linux 下编译出的二进制文件，丢到服务器上直接就能跑，不需要担心像 Windows 编译时可能带入的特定 DLL 依赖问题

User Space and Kernel Space

Wed, 04 Feb 2026 00:00:00 GMT

在 Linux 操作系统中，用户空间 (User Space) 和 内核空间 (Kernel Space) 是操作系统为了保证安全性和稳定性，在硬件（CPU）支持下进行的逻辑隔离

定义

用户空间
用户空间是普通应用程序运行的地方，具有低特权级别，不能直接访问底层硬件和受保护的内存区域

内核空间
内核空间是操作系统的核心（Kernel）运行的地方。它拥有最高特权，可以直接控制 CPU、内存、磁盘、网卡等所有硬件资源

异同

特性	用户空间	内核空间
特权等级	低特权 (Ring 3)	高特权 (Ring 0)
硬件访问	不允许直接访问，必须通过系统调用	可以直接访问 CPU、内存、I/O 等
内存分配	只能访问被分配的私有内存	可以访问整个物理内存
奔溃后果	仅当前进程崩溃，系统依然稳定	可能导致内核恐慌 (Kernel Panic)，系统重启
主要任务	运行各类应用软件	资源调度、内存管理、硬件驱动、进程管理

误解:权限和空间

当我们使用 root 权限执行命令的时候，这个命令也是在用户空间操作的，而不是在内核空间下完成的

运行模式(即空间的划分)是在硬件层面的，两个空间就如同一个有窗户相隔的两个房间，代码的执行在用户空间进行，只是需要使用资源的时候通过窗户call一下内核空间，而不可能直接打破墙去内核空间操作

[!note] 当然也有可以直接在内核空间操作的方法：

编写并加载内核模块 (LKM)：比如你写了一个 .ko 驱动文件，用 insmod 加载。这段代码会直接并入内核，拥有毁灭一切的权限。

修改内核源码：重新编译 Linux 内核（比如你打算给 Arch Linux 换个自定义内核）

查看内核空间命令

我们知道用户空间执行命令的时候会向内核空间请求和发送系统调用，内核处理完成后会返回给程序返回值，而我们可以使用[[系统调用追踪]]也就是strace来观察用户空间和内核空间的交互通信

多线程与并发

Wed, 04 Feb 2026 00:00:00 GMT

不要通过共享内存来通信，而要通过通信来共享内存

概念明晰

在深入了解并发前我们需要了解一些关于多线程和并发编程中常见的概念

并发：是指你的程序有处理多个任务的能力。在一个单核 CPU 上，通过快速切换任务，看起来像是同时在做很多事，但实际上某一时刻只有一个任务在运行。
并行：是指你的程序有同时执行多个任务的能力。这需要多核 CPU 的硬件支持，让不同的任务真正地在不同的核心上同时运转。

同时在我们需要了解一下进程，线程和协程三者的区别

特性	进程 (Process)	线程 (Thread)	协程 (Goroutine)
拥有者	操作系统	操作系统	Go 运行时 (Runtime)
内存占用	很大 (MB 级别)	较大 (~1MB)	极小 (初始仅 2KB)
切换开销	极高 (内核态切换)	高 (涉及寄存器保存)	极低 (用户态切换)
通信方式	IPC (管道、信号量)	共享内存 (需加锁)	Channel (推荐)、共享内存

Goroutine

语法

在Go语言中开启一个并发任务十分简单，只需要在函数之前添加一个 go 关键字

go function(params)

底层逻辑：

非阻塞：调用后，主程序会立即向下执行，不会等待 doSomething 返回。
匿名函数：常用 go func() { ... }() 的形式开启，但要注意闭包捕获变量的坑（在循环中直接使用循环变量可能会导致所有协程引用同一个值）。

生命周期管理

协程虽然轻量，但是对于其的生命周期管理也是必须的，如果管理不当，会导致 Goroutime泄露 问题

生命周期：

启动 : 通过 go 关键字
运行 : 由GMP调度器分配到逻辑处理器上
退出：
1. 函数体执行完毕
2. main函数结束
3. 发生不可恢复的 panic

GMP模型

在Go语言协程调度中有三个关键角色

角色	全称	作用
G	Goroutine	协程。包含栈内存、指令指针等。它不直接运行，而是被调度的单位。
M	Machine	操作系统线程（OS Thread）。它是真正的执行单元。M 必须绑定 P 才能运行 G。
P	Processor	逻辑处理器。它像一个“入场券”和“资源桶”，维护着一个本地待运行的 G 队列。

调度全景：

我们执行 go func() 产生一个G
G优先放入当前 P 的本地队列，如果本地满了，才放入全局队列
M 获取一个 P，然后从P的本地队列中取出G执行
如果本地队列、全局队列都空了，M 就会启动 Work Stealing 从其他 P 偷任务。

Channel

Channel可以翻译成通道，和linux下的[[Shell#^shttyz|pipe]]不同，Go语言中是我们可以看作是一个有类型的管道

语法

channel的使用符号为<-，我们可以将其看作数据流动的方向

创建Channel：

// 创建一个传递整型的管道
ch := make(chan int)

// 创建一个转递字符串的管道，并且带有3个容量的缓冲区
ch1 := make(chan string,3)

发送数据

ch <- 100   //将数字100发送到管道ch中

接受数据

data := <- ch   //从管道中取出一个值并且赋值给 data

关闭管道：
这是用来通知接收方以后没有数据进来了

close(ch)

阻塞

管道的发送和接受收到阻塞的约束

发送阻塞：如果你往管道里塞东西，但没人接，你就会在那儿等着（阻塞），直到有人来拿。
接收阻塞：如果你从管道里取东西，但里面是空的，你也会在那儿等着（阻塞），直到有人塞进一个东西。
需要注意的是有缓冲管道和无缓冲管道的阻塞情况不同
无缓冲管道要求管道的接受和发送都必须同步，否则就会一直阻塞
有缓冲管道会在管道满或空的时候发生阻塞

select多路复用

我们在处理多个协程通信的时候可以使用select来帮助我们

select 看起来像 switch，但它是专门为通道设计的，它会伪随机的选择一个可运行的 case 执行。

ch1 := make(chan int, 1)
ch2 := make(chan int, 1)

ch1 <- 1
ch2 <- 2

select {
case v1 := <-ch1:
    fmt.Println("执行了 ch1:", v1)
case v2 := <-ch2:
    fmt.Println("执行了 ch2:", v2)
}

fmt.Println("select 结束了")

我们如果想要实现处理所有数据，标准的做法是套上 for

for {
    select {
    case v1 := <-ch1:
        fmt.Println("处理 ch1:", v1)
    case v2 := <-ch2:
        fmt.Println("处理 ch2:", v2)
    default:
        // 如果两个都没数据了，可以在这里退出循环或者做点别的
        fmt.Println("暂时没数据了")
        return 
    }
}

Channel的实际使用

在匿名函数中使用

func fu() {
	ch := make(chan int) 
	go func(){
		fmt.Println("ok")
		ch <- 1     // 发送数据
	}()
	<- ch	// 等待接受到数据
	fmt.Println("喵")
}

作为具体参数传入

func downloader(url string, resultCh chan string) {
    // 模拟下载
    res := "下载完成: " + url
    resultCh <- res // 把结果发回管道
}

func main() {
    ch := make(chan string)
    // 启动具名函数
    go downloader("https://google.com", ch)
    fmt.Println(<-ch)
}

作为结构体的成员

当我们构建复杂系统的时候，channel通常是结构体的一部分，用来控制这个实例的状态或传递数据

type Worker struct {
    ID     int
    JobCh  chan int    // 接收任务的管道
    QuitCh chan bool   // 接收停止信号的管道
}

func (w *Worker) Start() {
    go func() {
        for {
            select {
            case job := <-w.JobCh:
                fmt.Printf("工人 %d 正在处理任务 %d\n", w.ID, job)
            case <-w.QuitCh:
                fmt.Printf("工人 %d 关机下班\n", w.ID)
                return
            }
        }
    }()
}

工厂模式

作为一个函数的返回值用来创建一个管道并且启动一个协程往里面灌数据，然后将管道返回调用者

func dataProducer() <-chan int {
    ch := make(chan int)
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
        }
        close(ch)
    }()
    return ch // 返回一个只读管道
}