火花花的领地

Linux命令速查手册

Mon, 25 May 2026 00:00:00 GMT

Linux命令速查手册

本文整理了Linux常用命令，按功能分类，方便快速查阅。点击命令可跳转到详细教程。

📚 配套教程：Linux操作大全（十篇完整教程）

📁 1. 文件管理

命令	说明	常用示例	详细教程
ls	列出目录内容	`ls -la`	基础入门
cd	切换目录	`cd /home`	基础入门
pwd	显示当前目录	`pwd`	基础入门
cp	复制文件/目录	`cp -r dir1 dir2`	文件与目录
mv	移动/重命名	`mv file1 file2`	文件与目录
rm	删除文件/目录	`rm -rf dir`	文件与目录
mkdir	创建目录	`mkdir -p dir1/dir2`	文件与目录
touch	创建空文件	`touch file.txt`	文件与目录
ln	创建链接	`ln -s file link`	文件与目录
find	查找文件	`find / -name "*.txt"`	文件与目录
locate	快速查找文件	`locate file.txt`	文件与目录
file	识别文件类型	`file image.jpg`	文件与目录
stat	显示文件状态	`stat file.txt`	文件与目录
tree	树状显示目录	`tree -L 2`	文件与目录
tar	打包压缩	`tar -czf file.tar.gz dir`	文件与目录
zip	压缩文件	`zip -r file.zip dir`	文件与目录
unzip	解压zip文件	`unzip file.zip`	文件与目录
gzip	gzip压缩	`gzip file.txt`	文件与目录
which	查找命令路径	`which python`	基础入门
whereis	查找命令/源码/手册	`whereis ls`	基础入门

📝 2. 文档编辑

命令	说明	常用示例	详细教程
cat	显示文件内容	`cat file.txt`	文件与目录
less	分页查看文件	`less file.txt`	文件与目录
more	分页查看文件	`more file.txt`	文件与目录
head	显示文件开头	`head -n 20 file.txt`	文件与目录
tail	显示文件结尾	`tail -f file.log`	文件与目录
grep	文本搜索	`grep "keyword" file`	文件与目录
sed	流编辑器	`sed 's/old/new/g' file`	文件与目录
awk	文本处理	`awk '{print $1}' file`	文件与目录
sort	排序	`sort file.txt`	文件与目录
uniq	去重	`uniq file.txt`	文件与目录
wc	统计行数/字数	`wc -l file.txt`	文件与目录
diff	比较文件差异	`diff file1 file2`	文件与目录
echo	输出字符串	`echo "hello"`	基础入门
sh	Shell解释器	`sh script.sh`	Shell编程
bash	Bash Shell	`bash script.sh`	Shell编程
vi/vim	文本编辑器	`vim file.txt`	基础入门
nano	简单编辑器	`nano file.txt`	基础入门

⚙️ 3. 系统管理

命令	说明	常用示例	详细教程
ps	显示进程状态	`ps aux`	进程管理
top	实时进程监控	`top`	进程管理
htop	增强版top	`htop`	进程管理
kill	终止进程	`kill -9 PID`	进程管理
pkill	按名称终止进程	`pkill nginx`	进程管理
killall	按名称终止所有进程	`killall nginx`	进程管理
pgrep	按名称查找进程	`pgrep nginx`	进程管理
pidof	查找进程ID	`pidof nginx`	进程管理
systemctl	服务管理	`systemctl start nginx`	进程管理
service	服务管理（旧）	`service nginx start`	进程管理
useradd	创建用户	`useradd -m user`	用户与权限
usermod	修改用户	`usermod -aG sudo user`	用户与权限
userdel	删除用户	`userdel -r user`	用户与权限
passwd	设置密码	`passwd user`	用户与权限
chmod	修改权限	`chmod 755 file`	文件与目录
chown	修改所有者	`chown user:group file`	文件与目录
sudo	以root权限执行	`sudo command`	用户与权限
su	切换用户	`su - user`	用户与权限
who	显示登录用户	`who`	用户与权限
w	显示登录用户详情	`w`	用户与权限
id	显示用户ID	`id`	用户与权限
groups	显示用户组	`groups`	用户与权限
crontab	定时任务	`crontab -e`	进程管理
at	一次性定时任务	`at 10:00 PM`	进程管理
uname	显示系统信息	`uname -a`	基础入门
hostname	显示/设置主机名	`hostname`	基础入门
date	显示/设置日期	`date`	基础入门
history	命令历史	`history`	基础入门
clear	清屏	`clear`	基础入门
reboot	重启系统	`sudo reboot`	基础入门
shutdown	关机	`shutdown -h now`	基础入门
journalctl	查看系统日志	`journalctl -f`	进程管理

💾 4. 磁盘管理

命令	说明	常用示例	详细教程
df	显示磁盘使用	`df -h`	磁盘管理
du	显示目录大小	`du -sh /path`	磁盘管理
fdisk	磁盘分区	`fdisk /dev/sdb`	磁盘管理
mkfs	格式化分区	`mkfs.ext4 /dev/sdb1`	磁盘管理
mount	挂载文件系统	`mount /dev/sdb1 /mnt`	磁盘管理
umount	卸载文件系统	`umount /mnt`	磁盘管理
lsblk	列出块设备	`lsblk`	磁盘管理
parted	磁盘分区（GPT）	`parted /dev/sdb`	磁盘管理
blkid	显示块设备UUID	`blkid`	磁盘管理
free	显示内存使用	`free -h`	系统监控
uptime	系统运行时间	`uptime`	系统监控
vmstat	系统资源统计	`vmstat 1`	系统监控
iostat	磁盘IO统计	`iostat -x 1`	系统监控
sar	系统活动报告	`sar -u 1 3`	系统监控
swapon	启用swap	`swapon /swapfile`	磁盘管理
dd	磁盘复制	`dd if=/dev/sda of=disk.img`	磁盘管理

📡 5. 网络通讯

命令	说明	常用示例	详细教程
ping	测试连通性	`ping google.com`	网络配置
curl	HTTP请求	`curl https://example.com`	网络配置
wget	下载文件	`wget https://example.com/file`	网络配置
ssh	远程登录	`ssh user@host`	网络配置
scp	远程复制	`scp file user@host:/path`	网络配置
rsync	远程同步	`rsync -avz dir user@host:/path`	网络配置
ifconfig	网络接口配置	`ifconfig`	网络配置
ip	网络配置	`ip addr show`	网络配置
netstat	网络状态	`netstat -tuln`	网络配置
ss	套接字统计	`ss -tuln`	网络配置
traceroute	路由追踪	`traceroute google.com`	网络配置
nslookup	DNS查询	`nslookup google.com`	网络配置
dig	DNS查询	`dig google.com`	网络配置
ufw	防火墙（Ubuntu）	`ufw enable`	网络配置
iptables	防火墙（底层）	`iptables -L`	网络配置
mtr	网络诊断工具	`mtr google.com`	网络配置
nmap	网络扫描	`nmap 192.168.1.1`	网络配置

🖥️ 6. 文件传输

命令	说明	常用示例	详细教程
ftp	FTP客户端	`ftp host`	网络配置
sftp	安全FTP	`sftp user@host`	网络配置

🔧 7. 设备管理

命令	说明	常用示例	详细教程
lspci	列出PCI设备	`lspci`	系统监控
lsusb	列出USB设备	`lsusb`	系统监控
lscpu	显示CPU信息	`lscpu`	系统监控
sensors	硬件温度	`sensors`	系统监控
dmesg	内核日志	`dmesg \| tail`	系统监控

📦 8. 软件包管理

命令	说明	常用示例	详细教程
apt	Debian/Ubuntu包管理	`apt install nginx`	网络配置
yum	CentOS/RHEL包管理	`yum install nginx`	软件包管理
dnf	Fedora包管理	`dnf install nginx`	软件包管理
snap	Snap包管理	`snap install code`	软件包管理
flatpak	Flatpak包管理	`flatpak install flathub org.gimp.GIMP`	软件包管理
rpm	RPM包管理	`rpm -ivh package.rpm`	软件包管理
dpkg	Debian包管理	`dpkg -i package.deb`	软件包管理
pip	Python包管理	`pip install requests`	软件包管理
npm	Node.js包管理	`npm install express`	软件包管理

🐳 9. Docker容器

命令	说明	常用示例	详细教程
docker	Docker命令	`docker run -d nginx`	Docker容器
docker-compose	编排多容器	`docker-compose up -d`	Docker容器

🔀 10. Git版本控制

命令	说明	常用示例	详细教程
git init	初始化仓库	`git init`	Git完全指南
git clone	克隆远程仓库	`git clone url`	Git完全指南
git add	添加到暂存区	`git add .`	Git完全指南
git commit	提交更改	`git commit -m "msg"`	Git完全指南
git status	查看状态	`git status`	Git完全指南
git diff	查看差异	`git diff`	Git完全指南
git log	查看历史	`git log --oneline`	Git完全指南
git branch	分支管理	`git branch feature`	Git完全指南
git checkout	切换分支	`git checkout feature`	Git完全指南
git switch	切换分支（新）	`git switch feature`	Git完全指南
git merge	合并分支	`git merge feature`	Git完全指南
git rebase	变基	`git rebase main`	Git完全指南
git remote	远程仓库管理	`git remote -v`	Git完全指南
git push	推送到远程	`git push origin main`	Git完全指南
git pull	拉取更新	`git pull origin main`	Git完全指南
git fetch	获取远程更新	`git fetch origin`	Git完全指南
git tag	标签管理	`git tag v1.0.0`	Git完全指南
git stash	暂存工作	`git stash`	Git完全指南
git reset	回退提交	`git reset --hard HEAD~1`	Git完全指南
git revert	安全回退	`git revert HEAD`	Git完全指南
git cherry-pick	选择提交	`git cherry-pick abc123`	Git完全指南
git reflog	操作历史	`git reflog`	Git完全指南
git config	配置管理	`git config --global user.name`	Git完全指南

🔍 11. 其他常用

命令	说明	常用示例	详细教程
man	查看手册	`man ls`	基础入门
alias	命令别名	`alias ll='ls -la'`	基础入门
export	设置环境变量	`export PATH=$PATH:/new`	基础入门
source	执行配置文件	`source ~/.bashrc`	基础入门
xargs	参数传递	`find . -name "*.txt" \| xargs rm`	Shell脚本
tee	输出到文件和屏幕	`command \| tee log.txt`	Shell脚本
watch	定时执行命令	`watch -n 1 df -h`	Shell脚本
nohup	后台运行	`nohup command &`	进程管理
screen	终端复用	`screen -S name`	进程管理
tmux	终端复用（推荐）	`tmux new -s name`	进程管理

📖 点击命令名称可跳转到对应的详细教程章节！

🔗 配套教程：Linux操作大全（十一篇完整教程）

📝 实用配置：Linux常用别名配置 — 将常用别名添加到 ~/.bashrc 中，提高操作效率

🔗 配套教程：Linux操作大全（十篇完整教程）

📝 实用配置：Linux常用别名配置 — 将常用别名添加到 ~/.bashrc 中，提高操作效率

🎉 火花花的领地，开张啦！

Mon, 18 May 2026 00:00:00 GMT

🎉 开张大吉！

你好呀，这里是 火花花 的小博客～

2026年5月18日，这个小小的角落正式开张了！🎊 以后会在这里记录一些日常、技术笔记、生活感悟，还有各种乱七八糟想写的东西。

📝 这里有什么？

板块	内容
📖 博客文章	技术笔记、生活记录、各种想法
📓 日记	日常碎碎念，看看我在干嘛
🎬 番剧	看过的动画、评分和感想
💻 项目	折腾过的一些代码项目
🛠 技能	我掌握的一些技能汇总
📸 相册	随手拍的照片、喜欢的图片

内容会慢慢丰富起来，不定期更新～

💬 关于评论

每篇文章下面都可以留言，欢迎来聊聊天！有什么想说的、想问的，或者想分享的，都可以写下来。我会看的～虽然不一定每条都回，但看到有意思的评论会很开心！😊

🔗 关于友链

以后会开友链页面，欢迎互相链接！如果你想跟我的博客交换友链，可以在评论区留言或者联系我～

🚀 最后

感谢你来到这里。不管你是偶然路过，还是特地来的，都欢迎～

希望这个小小的博客，能给你带来一些有趣的内容、一点温暖，或者只是一个让你放松一下的地方。

那么，接下来就慢慢更新起来吧！

—— 火花花 💕

LaTeX语法完全指南：从入门到精通

Fri, 05 Jun 2026 00:00:00 GMT

LaTeX语法完全指南：从入门到精通

LaTeX是一种高质量的排版系统，特别适合科技文档和数学公式的排版。本文将全面介绍LaTeX的语法和使用方法。

一、LaTeX简介

1.1 什么是LaTeX？

LaTeX（读作"拉泰赫"或"莱特克斯"）是一种基于TeX的排版系统，由Leslie Lamport在1984年开发。它的设计目标是让作者能够专注于内容，而将排版工作交给系统自动完成。

1.2 为什么使用LaTeX？

优势	说明
专业排版	自动生成高质量的文档，特别适合学术论文
数学公式	数学公式排版能力无与伦比
交叉引用	自动生成章节、公式、图表的编号和引用
稳定性	文档格式稳定，不受软件版本影响
免费开源	完全免费，跨平台支持

1.3 LaTeX vs Word

对比项	LaTeX	Word
学习曲线	陡峭	平缓
数学公式	极佳	一般
长文档	优秀	较差
版本控制	支持（纯文本）	困难（二进制）
协作	需要Git等工具	实时协作

二、文档结构

2.1 基本文档结构

\documentclass[选项]{文档类}

% 导言区：加载宏包、定义命令
\usepackage{宏包名}

% 正文开始
\begin{document}

% 文档内容
这里是正文内容

\end{document}

2.2 文档类

文档类	说明	适用场景
`article`	文章	短文、报告、论文
`report`	报告	长报告、学位论文
`book`	书籍	书籍、教材
`letter`	信件	书信
`beamer`	演示文稿	幻灯片

2.3 文档类选项

% 字体大小选项
\documentclass[12pt]{article}  % 12号字体

% 纸张大小选项
\documentclass[a4paper]{article}  % A4纸

% 双面打印
\documentclass[twoside]{article}  % 双面

% 组合选项
\documentclass[12pt,a4paper,twoside]{article}

2.4 页面设置

\usepackage{geometry}
\geometry{
    a4paper,
    left=2.5cm,
    right=2.5cm,
    top=2.5cm,
    bottom=2.5cm
}

三、文本格式化

3.1 字体样式

% 直立字体
\textup{直立字体}

% 意大利体（斜体）
\textit{意大利体}

% 粗体
\textbf{粗体}

% 等宽字体
\texttt{等宽字体}

% 小型大写字母
\textsc{小型大写}

% 下划线
\underline{下划线}

% 删除线（需要ulem宏包）
\sout{删除线}

3.2 字体大小

% 从小到大
{\tiny 极小}
{\scriptsize 脚本大小}
{\footnotesize 脚注大小}
{\small 小}
{\normalsize 正常}
{\large 大}
{\Large 更大}
{\LARGE 再大}
{\huge 巨大}
{\Huge 最大}

3.3 文本对齐

% 居中环境
\begin{center}
居中文本
\end{center}

% 右对齐环境
\begin{flushright}
右对齐文本
\end{flushright}

% 左对齐环境
\begin{flushleft}
左对齐文本
\end{flushleft}

3.4 特殊字符

\#    % 井号
\$    % 美元符号
\%    % 百分号
\^    % 脱字符
\&    % 和号
\_    % 下划线
\{    % 左花括号
\}    % 右花括号
\~    % 波浪号
\\    % 反斜杠

3.5 段落控制

% 换行（不新起段落）
第一行内容\\
第二行内容

% 新段落
第一段内容

第二段内容

% 强制换页
\newpage

% 无缩进
\noindent 这段没有缩进

% 设置段落缩进
\setlength{\parindent}{2em}

四、数学公式

LaTeX最强大的功能之一就是数学公式排版。

4.1 行内公式

% 使用 $...$ 或 \(...\)
爱因斯坦的质能方程 $E=mc^2$ 是物理学的基础。
爱因斯坦的质能方程 \(E=mc^2\) 是物理学的基础。

4.2 行间公式

% 使用 \[...\] 或 equation 环境
\[
E = mc^2
\]

% 带编号的公式
\begin{equation}
E = mc^2
\end{equation}

% 不带编号
\begin{equation*}
E = mc^2
\end{equation*}

4.3 基本数学符号

% 运算符
+ - * /          % 基本运算
\times           % 乘号 ×
\div             % 除号 ÷
\pm              % 正负 ±
\mp              % 负正 ∓
\cdot            % 点乘 ·

% 关系符
=                % 等号
\neq             % 不等号 ≠
< >              % 小于大于
\leq             % 小于等于 ≤
\geq             % 大于等于 ≥
\approx          % 约等于 ≈
\equiv           % 恒等于 ≡
\sim             % 相似 ~

4.4 上下标

% 上标
x^2              % x的平方
x^{2n}           % x的2n次方（多字符需要用花括号）

% 下标
a_1              % a下标1
a_{n+1}          % a下标n+1

% 组合
x_i^2            % x下标i，上标2
x_{i}^{2}        % 同上，更清晰

4.5 分数与根号

% 分数
\frac{分子}{分母}
\frac{1}{2}      % 二分之一
\frac{a+b}{c+d}  % 分数

% 根号
\sqrt{x}         % 平方根
\sqrt[3]{x}      % 立方根
\sqrt[n]{x}      % n次根

4.6 求和与积分

% 求和
\sum_{i=1}^{n} x_i       % 求和符号
\sum_{i=1}^{\infty} x_i  % 无穷求和

% 积分
\int_{a}^{b} f(x) dx     % 定积分
\int f(x) dx              % 不定积分
\iint f(x,y) dxdy        % 二重积分
\iiint f(x,y,z) dxdydz   % 三重积分

% 极限
\lim_{x \to \infty} f(x) % 极限
\lim_{x \to 0} \frac{\sin x}{x} = 1

4.7 矩阵

% 基本矩阵
\begin{matrix}
a & b \\
c & d
\end{matrix}

% 带括号的矩阵
\begin{pmatrix}
a & b \\
c & d
\end{pmatrix}

% 方括号矩阵
\begin{bmatrix}
a & b \\
c & d
\end{bmatrix}

% 花括号矩阵
\begin{Bmatrix}
a & b \\
c & d
\end{Bmatrix}

% 行列式
\begin{vmatrix}
a & b \\
c & d
\end{vmatrix}

4.8 多行公式

% align 环境（对齐等号）
\begin{align}
f(x) &= (x+1)^2 \\
     &= x^2 + 2x + 1
\end{align}

% 不带编号
\begin{align*}
f(x) &= (x+1)^2 \\
     &= x^2 + 2x + 1
\end{align*}

% cases 环境（分段函数）
f(x) = \begin{cases}
x^2 & \text{if } x \geq 0 \\
-x  & \text{if } x < 0
\end{cases}

4.9 希腊字母

% 小写希腊字母
\alpha \beta \gamma \delta \epsilon \zeta \eta \theta
\iota \kappa \lambda \mu \nu \xi \pi \rho \sigma \tau
\upsilon \phi \chi \psi \omega

% 大写希腊字母
\Gamma \Delta \Theta \Lambda \Xi \Pi \Sigma \Phi \Psi \Omega

4.10 数学字体

% 粗体（向量、矩阵）
\mathbf{ABC}        % 粗体
\boldsymbol{ABC}    % 粗斜体

% 花体
\mathcal{ABC}       % 花体字母

% 黑板粗体
\mathbb{R}          % 实数集 ℝ
\mathbb{N}          % 自然数集 ℕ
\mathbb{Z}          % 整数集 ℤ
\mathbb{Q}          % 有理数集 ℚ
\mathbb{C}          % 复数集 ℂ

% 罗马字体
\mathrm{ABC}        % 直立字体

% 斜体
\mathit{ABC}        % 斜体

% 等宽
\mathtt{ABC}        % 等宽字体

五、列表

5.1 无序列表

\begin{itemize}
  \item 第一项
  \item 第二项
  \item 第三项
\end{itemize}

5.2 有序列表

\begin{enumerate}
  \item 第一项
  \item 第二项
  \item 第三项
\end{enumerate}

5.3 描述列表

\begin{description}
  \item[术语1] 解释1
  \item[术语2] 解释2
  \item[术语3] 解释3
\end{description}

5.4 嵌套列表

\begin{enumerate}
  \item 第一层
    \begin{enumerate}
      \item 第二层
      \item 第二层
    \end{enumerate}
  \item 第一层
\end{enumerate}

六、表格

6.1 基本表格

\begin{table}[h]
\centering
\caption{表格标题}
\begin{tabular}{|l|c|r|}
\hline
左对齐 & 居中 & 右对齐 \\
\hline
数据1 & 数据2 & 数据3 \\
数据4 & 数据5 & 数据6 \\
\hline
\end{tabular}
\end{table}

6.2 列格式说明

格式	说明
`l`	左对齐
`c`	居中
`r`	右对齐
`	`
`

6.3 复杂表格

\begin{table}[h]
\centering
\caption{学生成绩表}
\begin{tabular}{|l|c|c|c|}
\hline
\textbf{姓名} & \textbf{语文} & \textbf{数学} & \textbf{英语} \\
\hline
张三 & 85 & 92 & 78 \\
李四 & 90 & 88 & 95 \\
王五 & 78 & 95 & 82 \\
\hline
\end{tabular}
\end{table}

6.4 合并单元格

% 合并列
\begin{tabular}{|l|c|c|}
\hline
\multicolumn{2}{|c|}{合并两列} & 单独列 \\
\hline
A & B & C \\
\hline
\end{tabular}

% 合并行（需要multirow宏包）
\begin{tabular}{|l|c|}
\hline
\multirow{2}{*}{合并两行} & 第一行 \\
                          & 第二行 \\
\hline
\end{tabular}

6.5 跨页长表格

\usepackage{longtable}

\begin{longtable}{|l|c|r|}
\caption{长表格标题} \\
\hline
\textbf{列1} & \textbf{列2} & \textbf{列3} \\
\hline
\endfirsthead

\hline
\textbf{列1} & \textbf{列2} & \textbf{列3} \\
\hline
\endhead

\hline
\endfoot

数据1 & 数据2 & 数据3 \\
数据4 & 数据5 & 数据6 \\
...更多数据...
\end{longtable}

七、图片插入

7.1 基本图片插入

\usepackage{graphicx}

\begin{figure}[h]
\centering
\includegraphics[width=0.8\textwidth]{image.png}
\caption{图片标题}
\label{fig:myimage}
\end{figure}

7.2 图片选项

选项	说明
`width`	宽度
`height`	高度
`scale`	缩放比例
`angle`	旋转角度

% 设置宽度
\includegraphics[width=5cm]{image.png}

% 设置高度
\includegraphics[height=3cm]{image.png}

% 缩放
\includegraphics[scale=0.5]{image.png}

% 旋转
\includegraphics[angle=45]{image.png}

% 组合
\includegraphics[width=0.8\textwidth, angle=0]{image.png}

7.3 浮动体位置

选项	说明
`h`	here，当前位置
`t`	top，页面顶部
`b`	bottom，页面底部
`p`	page，单独一页
`!`	忽略内部参数

\begin{figure}[htbp]
% 尝试放在当前位置，不行就放顶部、底部、单独页
\end{figure}

7.4 并排图片

\begin{figure}[h]
\centering
\begin{minipage}{0.45\textwidth}
\centering
\includegraphics[width=\textwidth]{image1.png}
\caption{图片1}
\end{minipage}
\hfill
\begin{minipage}{0.45\textwidth}
\centering
\includegraphics[width=\textwidth]{image2.png}
\caption{图片2}
\end{minipage}
\end{figure}

八、引用与参考文献

8.1 交叉引用

% 标签
\label{标签名}

% 引用
\ref{标签名}      % 引用编号
\pageref{标签名}  % 引用页码

% 示例
如图\ref{fig:myimage}所示...
如公式\ref{eq:einstein}所示...
见第\pageref{sec:intro}页...

8.2 脚注

这是正文内容\footnote{这是脚注内容}。

8.3 参考文献（BibTeX）

% 在导言区
\bibliographystyle{plain}
\bibliography{references}

% 在正文中引用
\cite{引用键}

% references.bib 文件
@article{einstein1905,
  author = {Einstein, Albert},
  title = {On the Electrodynamics of Moving Bodies},
  journal = {Annalen der Physik},
  year = {1905},
  volume = {322},
  pages = {891--921}
}

8.4 natbib宏包

\usepackage{natbib}

% 引用格式
\citet{einstein1905}    % Einstein (1905)
\citep{einstein1905}    % (Einstein, 1905)
\citep[see][]{einstein1905}  % (see Einstein, 1905)
\citep[p.~10]{einstein1905}  % (Einstein, 1905, p. 10)

九、代码排版

9.1 行内代码

使用\texttt{print()}函数输出。

9.2 代码块（listings宏包）

\usepackage{listings}
\usepackage{xcolor}

\lstset{
    language=Python,
    basicstyle=\ttfamily\small,
    keywordstyle=\color{blue}\bfseries,
    commentstyle=\color{green!60!black},
    stringstyle=\color{red},
    numbers=left,
    numberstyle=\tiny\color{gray},
    frame=single,
    breaklines=true,
    captionpos=b
}

\begin{lstlisting}[caption={Python示例}]
def hello():
    print("Hello, LaTeX!")

hello()
\end{lstlisting}

9.3 minted宏包（代码高亮）

\usepackage{minted}

\begin{minted}{python}
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
\end{minted}

十、高级功能

10.1 自定义命令

% 简单命令
\newcommand{\R}{\mathbb{R}}          % 实数集
\newcommand{\N}{\mathbb{N}}          % 自然数集
\newcommand{\norm}[1]{\|#1\|}        % 范数

% 带默认参数
\newcommand{\person}[2]{#1 #2}       % 姓名
\person{张}{三}                       % 输出：张三

10.2 自定义环境

% 定义定理环境
\newtheorem{theorem}{定理}
\newtheorem{lemma}[theorem]{引理}
\newtheorem{corollary}[theorem]{推论}

% 使用
\begin{theorem}
这是定理内容。
\end{theorem}

10.3 条件编译

\newif\ifdraft
\drafttrue    % 启用草稿模式
% \draftfalse  % 关闭草稿模式

\ifdraft
草稿模式：显示草稿标记
\else
正式模式：隐藏草稿标记
\fi

10.4 循环

\usepackage{pgffor}

\foreach \x in {1,2,...,10} {
    数字：\x
}

十一、常用宏包

11.1 文档类相关

宏包	用途
`geometry`	页面设置
`fancyhdr`	页眉页脚
`titlesec`	章节标题格式
`tocloft`	目录格式

11.2 数学相关

宏包	用途
`amsmath`	数学公式增强
`amssymb`	数学符号
`mathtools`	数学工具
`bm`	粗体数学符号

11.3 图表相关

宏包	用途
`graphicx`	图片插入
`booktabs`	专业表格
`multirow`	表格合并行
`longtable`	长表格
`subcaption`	子图

11.4 代码相关

宏包	用途
`listings`	代码排版
`minted`	代码高亮
`algorithm2e`	算法排版

11.5 中文支持

宏包	用途
`ctex`	中文支持（推荐）
`xeCJK`	XeLaTeX中文
`CJK`	传统中文支持

十二、实战技巧

12.1 学术论文模板

\documentclass[12pt,a4paper]{article}
\usepackage[UTF8]{ctex}
\usepackage{geometry}
\usepackage{amsmath,amssymb}
\usepackage{graphicx}
\usepackage{booktabs}
\usepackage{hyperref}

\geometry{left=2.5cm, right=2.5cm, top=2.5cm, bottom=2.5cm}

\title{论文标题}
\author{作者姓名}
\date{\today}

\begin{document}
\maketitle

\begin{abstract}
这是摘要内容。
\end{abstract}

\tableofcontents
\newpage

\section{引言}
正文内容...

\section{方法}
\subsection{数据收集}
具体内容...

\section{结论}
结论内容...

\bibliographystyle{plain}
\bibliography{references}
\end{document}

12.2 数学笔记模板

\documentclass[12pt]{article}
\usepackage[UTF8]{ctex}
\usepackage{amsmath,amssymb,mathtools}
\usepackage{geometry}
\usepackage{fancyhdr}

\pagestyle{fancy}
\fancyhf{}
\fancyhead[L]{数学笔记}
\fancyhead[R]{\thepage}

\newcommand{\R}{\mathbb{R}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\Z}{\mathbb{Z}}
\newcommand{\norm}[1]{\|#1\|}

\begin{document}

\section{线性代数}

\subsection{向量空间}

\begin{definition}
向量空间是一个集合 $V$，配备加法和标量乘法运算，满足以下公理...
\end{definition}

\begin{theorem}
设 $V$ 是有限维向量空间，则 $V$ 的任意两个基具有相同的基数。
\end{theorem}

\begin{proof}
设 $B_1$ 和 $B_2$ 是 $V$ 的两个基。由于 $B_1$ 线性无关且 $B_2$ 生成 $V$，故 $|B_1| \leq |B_2|$。同理 $|B_2| \leq |B_1|$，因此 $|B_1| = |B_2|$。
\end{proof}

\end{document}

12.3 Beamer演示文稿

\documentclass{beamer}
\usetheme{Madrid}
\usepackage[UTF8]{ctex}

\title{演示文稿标题}
\author{演讲者}
\date{\today}

\begin{document}

\begin{frame}
\titlepage
\end{frame}

\begin{frame}{大纲}
\tableofcontents
\end{frame}

\section{第一部分}

\begin{frame}{第一页}
\begin{itemize}
\item 要点一
\item 要点二
\item 要点三
\end{itemize}
\end{frame}

\begin{frame}{公式示例}
\begin{equation}
E = mc^2
\end{equation}
\end{frame}

\end{document}

12.4 常见问题解决

问题1：中文显示问题

% 使用ctex宏包
\usepackage[UTF8]{ctex}

% 或者使用xeCJK
\usepackage{xeCJK}
\setCJKmainfont{SimSun}  % 设置中文字体

问题2：图片找不到

% 设置图片路径
\graphicspath{{images/}{figures/}}

问题3：公式太长

% 使用multiline环境
\begin{multline}
f(x) = a + b + c + d + e + f + g + h + i + j \\
       + k + l + m + n + o + p + q + r + s + t
\end{multline}

问题4：表格太宽

% 使用resizebox
\resizebox{\textwidth}{!}{
\begin{tabular}{...}
...
\end{tabular}
}

📝 总结

核心要点

内容	要点
文档结构	documentclass → 导言区 → document环境
数学公式	$行内$、[行间]、equation环境
表格	tabular环境、booktabs宏包
图片	graphicx宏包、figure环境
引用	label和ref配合使用
中文支持	ctex宏包

学习建议

从模板开始：先用模板，再逐步修改
多写多练：LaTeX需要实践才能熟练
善用搜索：遇到问题先搜索解决方案
参考文档：查阅LaTeX官方文档和宏包文档

OS笔记（一）：进程与线程简介

Fri, 05 Jun 2026 00:00:00 GMT

OS笔记（一）：进程与线程简介

本文是操作系统笔记系列的第一篇，从最基础的概念讲起，帮助大家理解进程和线程到底是什么、有什么区别、在Linux中如何查看和管理。

📚 目录

一、什么是进程？
二、进程的组成
三、进程的特征
四、什么是线程？
五、进程与线程的区别
六、Linux实战：查看进程和线程
七、本章小结

一、什么是进程？

1.1 程序 vs 进程

概念	定义	特点
程序	存放在磁盘里的可执行文件	静态的，是一个文件
进程	程序的一次执行过程	动态的，是一个活动

关键理解：同一个程序多次执行会对应多个进程。比如你打开两个Chrome浏览器窗口，虽然程序文件是同一个，但它们是两个不同的进程。

1.2 进程的定义

进程（Process）是操作系统进行资源分配和调度的基本单位。每个进程都有自己独立的内存空间、文件描述符、环境变量等。

二、进程的组成

一个进程由三部分组成：

2.1 PCB（进程控制块）

PCB（Process Control Block）是进程存在的唯一标志。进程创建时会创建PCB，进程结束时会回收PCB。

PCB中存储的信息包括：

信息	说明
PID	进程ID，系统中唯一标识一个进程
进程状态	运行态、就绪态、阻塞态等
程序计数器	下一条要执行的指令地址
寄存器值	CPU寄存器的当前值
内存管理信息	页表、段表等
I/O状态信息	打开的文件、分配的设备等

2.2 程序段

程序段存放的是要执行的代码指令。

2.3 数据段

数据段存放的是程序运行时使用的数据（如全局变量、静态变量等）。

重点理解：

PCB是给操作系统用的，用于管理和控制进程

程序段、数据段是给进程自己使用的

三、进程的特征

特征	说明
动态性	进程是程序的一次执行过程，有创建、执行、消亡的生命周期
并发性	多个进程可以同时存在于内存中，并发执行
独立性	进程是资源分配的基本单位，各进程的地址空间相互独立
异步性	进程按各自独立的、不可预知的速度向前推进
结构性	进程由程序段、数据段和PCB三部分组成

四、什么是线程？

4.1 线程的概念

线程（Thread）可以理解为轻量级进程。它是CPU执行的基本单位，也是程序执行流的最小单位。

4.2 为什么需要线程？

引入线程的目的：

提高并发度：一个进程内的多个线程可以并发执行
减少开销：线程切换比进程切换开销小得多
共享资源：同一进程的线程共享进程的内存空间和资源

4.3 线程的特点

特点	说明
线程是处理机调度的基本单位	CPU分配是分配给线程的
线程几乎不拥有系统资源	资源由进程拥有
同一进程的线程共享进程资源	共享内存地址空间、文件等
线程切换开销小	不需要切换地址空间

五、进程与线程的区别

对比项	进程	线程
资源分配	资源分配的基本单位	CPU调度的基本单位
地址空间	每个进程有独立的地址空间	同一进程的线程共享地址空间
开销	创建、切换、销毁开销大	创建、切换、销毁开销小
通信	需要IPC机制（管道、消息队列等）	可以直接读写共享变量
崩溃影响	一个进程崩溃不影响其他进程	一个线程崩溃可能导致整个进程崩溃

六、Linux实战：查看进程和线程

6.1 查看进程

# 查看当前用户的进程
ps

# 查看所有进程
ps -ef

# 查看进程树
pstree

# 实时监控进程
top

6.2 查看进程详细信息

# 查看特定进程的详细信息
ps -p <PID> -f

# 查看进程的内存使用
ps -p <PID> -o pid,ppid,cmd,%mem,%cpu

# 查看进程打开的文件
lsof -p <PID>

6.3 查看线程

# 查看进程的线程
ps -T -p <PID>

# 查看所有线程
ps -eLf

# 使用top查看线程
top -H

6.4 进程管理命令

# 启动一个进程
./my_program &

# 终止进程
kill <PID>

# 强制终止进程
kill -9 <PID>

# 查看进程状态
cat /proc/<PID>/status

6.5 实际案例：理解进程和线程

# 启动一个Python程序，观察进程和线程
python3 -c "
import threading
import time

def worker():
    time.sleep(60)

# 创建3个线程
for i in range(3):
    t = threading.Thread(target=worker)
    t.start()

time.sleep(60)
" &

# 查看进程
ps -ef | grep python

# 查看线程
ps -T -p <PID>

七、本章小结

核心概念

概念	要点
进程	程序的一次执行过程，资源分配的基本单位
线程	CPU执行的基本单位，轻量级进程
PCB	进程存在的唯一标志
区别	进程独立、线程共享；进程开销大、线程开销小

考研/期末常见考点

进程和程序的区别（动态vs静态）
进程的组成（PCB、程序段、数据段）
PCB的作用（进程存在的唯一标志）
进程和线程的区别（资源分配、开销、通信）
线程的实现方式（用户级、内核级）

思考题

为什么说PCB是进程存在的唯一标志？
引入线程后，进程的作用发生了什么变化？
用户级线程和内核级线程有什么区别？

下一篇：OS笔记（二）：进程的状态与转换

OS笔记（二）：进程的状态与转换

Fri, 05 Jun 2026 00:00:00 GMT

OS笔记（二）：进程的状态与转换

本文是操作系统笔记系列的第二篇，详细讲解进程在生命周期中的五种状态、状态之间的转换条件，以及进程的组织方式。

📚 目录

一、进程的五种状态
二、状态之间的转换
三、进程的组织方式
四、Linux实战：观察进程状态
五、本章小结

一、进程的五种状态

进程在其生命周期中会经历以下五种状态：

状态	英文	含义
创建态	New	进程正在被创建，操作系统分配资源、初始化PCB
就绪态	Ready	已具备运行条件，但没有空闲CPU，暂时不能运行
运行态	Running	正在CPU上执行
阻塞态	Blocked/Waiting	因等待某事件（如I/O完成）而暂停运行
终止态	Terminated	进程执行完毕或被强制终止，系统回收资源

状态详解

创建态 → 就绪态

操作系统完成PCB初始化、分配内存等资源后，进程进入就绪队列

就绪态 → 运行态

进程被调度程序选中，获得CPU使用权

运行态 → 就绪态

时间片用完，或被更高优先级的进程抢占

运行态 → 阻塞态

进程主动请求某事件（如等待I/O、等待信号量）

阻塞态 → 就绪态

等待的事件发生（如I/O完成、收到信号）

运行态 → 终止态

进程执行完毕，或遇到致命错误，或被其他进程杀死

二、状态之间的转换

2.1 状态转换图

![状态转换图](/assets/os-notes/Pasted%20image%2020260603215722.webp)

### 2.2 转换条件总结

| 转换 | 触发条件 | 主动/被动 |
|------|----------|-----------|
| 创建→就绪 | PCB初始化完成 | 被动（OS完成） |
| 就绪→运行 | 被调度程序选中 | 被动（OS调度） |
| 运行→就绪 | 时间片用完/被抢占 | 被动 |
| 运行→阻塞 | 进程主动请求（如I/O） | **主动** |
| 阻塞→就绪 | 等待的事件发生 | 被动 |
| 运行→终止 | 执行完毕/被杀死 | 主动或被动 |

> **重点**：只有 **运行→阻塞** 是进程主动的行为，其他都是被动的！

---

<a id="组织"></a>
## 三、进程的组织方式

操作系统需要管理大量进程的PCB，常用以下两种组织方式：

### 3.1 链接方式

把同一状态的PCB组织成一个**链表**，操作系统持有指向各队列的指针。

3.2 索引方式

为每种状态建立一张索引表，表中存放指向PCB的指针。

![索引方式](/assets/os-notes/Pasted%20image%2020260603220053.webp)

---

<a id="linux"></a>
## 四、Linux实战：观察进程状态

### 4.1 Linux进程状态

Linux中进程状态用字母表示：

| 状态码 | 含义 | 对应OS概念 |
|--------|------|------------|
| **R** | Running/Runnable | 运行态/就绪态 |
| **S** | Sleeping（可中断） | 阻塞态 |
| **D** | Disk Sleep（不可中断） | 阻塞态（等I/O） |
| **T** | Stopped | 暂停态 |
| **Z** | Zombie | 终止态（未回收） |

### 4.2 查看进程状态

```bash
# 查看进程状态
ps aux | head -5
# USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
# root         1  0.0  0.1 169432 13200 ?        Ss   Jun04   0:05 /sbin/init

# STAT列含义：
# S = sleeping (阻塞)
# R = running (运行/就绪)
# D = disk sleep (不可中断阻塞)
# Z = zombie (僵尸)
# s = session leader
# + = foreground process

4.3 观察状态转换

# 创建一个会阻塞的进程（等待用户输入）
cat &

# 查看其状态（应该是 S = sleeping）
ps -p $! -o pid,stat,cmd

# 终止它
kill $!

4.4 僵尸进程实验

# 创建一个僵尸进程
python3 -c "
import os, time
pid = os.fork()
if pid == 0:
    # 子进程立即退出
    exit(0)
else:
    # 父进程不回收子进程，变成僵尸
    time.sleep(60)
" &

# 查看僵尸进程（状态为 Z）
ps aux | grep defunct

4.5 查看进程状态变化

# 使用top实时观察进程状态
top -p <PID>

# 使用strace跟踪系统调用
strace -p <PID>

五、本章小结

核心概念

概念	要点
五种状态	创建、就绪、运行、阻塞、终止
状态转换	就绪↔运行（调度）、运行→阻塞（主动）、阻塞→就绪（事件完成）
进程组织	链接方式（链表）、索引方式（索引表）
Linux状态	R(运行)、S(睡眠)、D(磁盘等待)、Z(僵尸)、T(暂停)

考研/期末常见考点

五种状态的含义和转换条件
运行→阻塞是唯一主动行为
就绪态和阻塞态的区别（有没有CPU）
进程组织的两种方式
Linux进程状态码的含义

思考题

为什么说"运行→阻塞"是进程的主动行为？
就绪态和阻塞态的本质区别是什么？
僵尸进程是怎么产生的？如何避免？

上一篇：OS笔记（一）：进程与线程简介 下一篇：OS笔记（三）：进程控制

OS笔记（三）：进程控制

Fri, 05 Jun 2026 00:00:00 GMT

OS笔记（三）：进程控制

本文是操作系统笔记系列的第三篇，详细讲解操作系统如何通过原语来控制进程的创建、终止、阻塞、唤醒和切换。

📚 目录

一、什么是原语？
二、进程创建
三、进程终止
四、进程阻塞与唤醒
五、进程切换
六、Linux实战：进程控制
七、本章小结

一、什么是原语？

1.1 原语的定义

原语（Primitive）是操作系统内核中由若干指令组成的原子操作，执行过程一气呵成，不可中断。

1.2 如何保证原子性？

使用 关中断指令 和 开中断指令 这两个特权指令：

关中断指令    ← 关闭中断响应
  操作1
  操作2
  ...
开中断指令    ← 恢复中断响应

原理：CPU执行关中断指令后，不再检查中断信号，直到执行开中断指令后才恢复。这样中间的指令序列就不可被中断了。

1.3 为什么需要原语？

进程控制涉及修改PCB、队列等关键数据结构，如果不原子执行，可能出现数据不一致的错误。

二、进程创建

2.1 创建原语的执行步骤

步骤	操作
1	申请空白PCB
2	为新进程分配所需资源（内存、文件等）
3	初始化PCB（PID、程序计数器、寄存器等）
4	将PCB插入就绪队列

2.2 引起进程创建的事件

事件	说明	示例
用户登录	用户登录系统时创建Shell进程	SSH登录
作业调度	从外存调入作业执行	批处理系统
提供服务	OS为用户请求创建服务进程	打印请求
应用请求	进程主动创建子进程	fork()系统调用

三、进程终止

3.1 撤销原语的执行步骤

步骤	操作
1	从PCB集合中找到终止进程的PCB
2	若进程正在运行，立即剥夺CPU
3	终止其所有子进程（级联终止）
4	将该进程拥有的所有资源归还给父进程或OS
5	删除PCB

3.2 引起进程终止的事件

事件	说明	示例
正常结束	进程执行完毕	程序运行结束
异常结束	遇到致命错误	段错误、除零错误
外界干预	被其他进程或管理员终止	kill命令

四、进程阻塞与唤醒

4.1 阻塞原语

步骤	操作
1	找到要阻塞的进程对应的PCB
2	保护进程运行现场，将PCB状态设为阻塞态
3	将PCB插入相应事件的等待队列

4.2 唤醒原语

步骤	操作
1	在事件等待队列中找到PCB
2	将PCB从等待队列中移除，设为就绪态
3	将PCB插入就绪队列

注意：阻塞是进程主动调用的（如等待I/O），唤醒是由其他进程或OS在事件完成时调用的。

五、进程切换

5.1 切换原语的执行步骤

步骤	操作
1	将运行环境信息（寄存器值等）存入当前进程的PCB
2	将当前PCB移入相应队列（就绪/阻塞）
3	选择另一个进程执行，更新其PCB
4	根据新进程的PCB恢复运行环境

5.2 引起进程切换的事件

事件	说明
时间片用完	当前进程时间片到，切换到下一个就绪进程
进程阻塞	当前进程主动阻塞，切换到其他就绪进程
更高优先级进程就绪	抢占式调度下，高优先级进程抢占CPU

六、Linux实战：进程控制

6.1 创建进程：fork()

# 在C语言中使用fork()创建子进程
cat > fork_demo.c << 'EOF'
#include <stdio.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    
    if (pid > 0) {
        // 父进程
        printf("父进程 PID=%d, 子进程 PID=%d\n", getpid(), pid);
    } else if (pid == 0) {
        // 子进程
        printf("子进程 PID=%d, 父进程 PID=%d\n", getpid(), getppid());
    }
    
    return 0;
}
EOF

gcc fork_demo.c -o fork_demo
./fork_demo

6.2 终止进程

# 正常终止
kill <PID>

# 发送SIGTERM信号（可被捕获）
kill -15 <PID>

# 强制终止（不可捕获）
kill -9 <PID>

# 按名称终止
pkill -f "python3 my_script.py"

# 终止所有同名进程
killall python3

6.3 进程状态管理

# 暂停进程（发送SIGSTOP）
kill -STOP <PID>

# 恢复进程（发送SIGCONT）
kill -CONT <PID>

# 实际操作
sleep 100 &
PID=$!
echo "进程 PID=$PID 已启动"

sleep 2
kill -STOP $PID
echo "进程已暂停"

sleep 2
kill -CONT $PID
echo "进程已恢复"

6.4 查看进程关系

# 查看进程树
pstree -p

# 查看特定进程的父进程
ps -p <PID> -o pid,ppid,cmd

# 查看子进程
ps --ppid <PID>

6.5 Shell中的进程控制

# 前台运行
./my_program

# 后台运行
./my_program &

# 查看后台任务
jobs

# 切换到前台
fg %1

# 继续后台运行
bg %1

# nohup保持运行（退出终端后继续）
nohup ./my_program &

七、本章小结

核心概念

概念	要点
原语	原子操作，用关中断/开中断保证
创建原语	申请PCB→分配资源→初始化→插入就绪队列
终止原语	找PCB→剥夺CPU→终止子进程→回收资源→删除PCB
阻塞原语	保护现场→设阻塞态→插入等待队列
唤醒原语	从等待队列移除→设就绪态→插入就绪队列
切换原语	保存环境→移队列→选新进程→恢复环境

考研/期末常见考点

原语的原子性如何保证（关中断/开中断）
五种原语的执行步骤
阻塞和唤醒的关系（阻塞主动，唤醒被动）
fork()的工作原理（子进程复制父进程）

思考题

为什么原语要用关中断/开中断来保证原子性？
进程被阻塞后，是谁把它唤醒的？
fork()之后，父进程和子进程的执行顺序是怎样的？

上一篇：OS笔记（二）：进程的状态与转换 下一篇：OS笔记（四）：进程通信

OS笔记（四）：进程通信

Fri, 05 Jun 2026 00:00:00 GMT

OS笔记（四）：进程通信

本文是操作系统笔记系列的第四篇，详细讲解进程间通信（IPC）的三种基本方式，以及Linux中IPC的实际使用方法。

📚 目录

一、为什么需要进程通信？
二、共享存储
三、消息传递
四、管道通信
五、信号
六、Linux实战：进程通信
七、本章小结

一、为什么需要进程通信？

1.1 进程的独立性

进程是分配系统资源的基本单位，各进程的内存地址空间相互独立：

![进程地址空间独立](/assets/os-notes/Pasted%20image%2020260604201148.webp)

### 1.2 安全考虑

为了保证安全，**一个进程不能直接访问另一个进程的地址空间**。因此需要操作系统提供专门的通信机制。

### 1.3 IPC的三种方式

| 方式 | 原理 | 特点 |
|------|------|------|
| **共享存储** | 在内存中开辟共享区域 | 速度快，需要同步 |
| **消息传递** | 通过发送/接收消息 | 灵活，开销较大 |
| **管道通信** | 通过管道文件连接 | 简单，单向传输 |

---

<a id="共享存储"></a>
## 二、共享存储

### 2.1 基本原理

操作系统在内存中划出一块**共享存储区**，多个进程可以访问这块区域进行数据交换。

![共享存储](/assets/os-notes/Pasted%20image%2020260604201841.webp)

### 2.2 两种类型

| 类型 | 说明 | 特点 |
|------|------|------|
| **基于数据结构的共享** | 共享固定大小的数据结构（如数组） | 限制多、速度慢、**低级通信** |
| **基于存储区的共享** | 共享原始内存区域，数据形式由进程自定 | 灵活、速度快、**高级通信** |

### 2.3 同步互斥

多个进程访问共享空间时需要**互斥**，通常使用操作系统提供的同步互斥工具（如P、V操作、信号量）。

---

<a id="消息传递"></a>
## 三、消息传递

### 3.1 基本原理

进程间的数据交换以**格式化的消息**为单位，通过操作系统提供的"发送消息/接收消息"原语进行数据交换。

消息结构：

3.2 两种方式

直接通信方式

发送方和接收方直接指定对方，点名道姓的消息传递。

间接通信方式

通过**信箱（Mailbox）**作为中间实体进行消息传递。

对比	直接通信	间接通信
寻址	直接指定进程PID	通过信箱名
耦合度	高	低
灵活性	低	高

四、管道通信

4.1 基本原理

管道（Pipe）是连接两个进程的共享文件，一个进程写入数据，另一个进程读取数据。

4.2 管道的特点

特点	说明
半双工	某一时间段内只能单向传输
互斥访问	各进程要互斥地访问管道
写满阻塞	管道写满时，写进程阻塞
读空阻塞	管道读空时，读进程阻塞
数据消失	数据一旦被读出就消失

4.3 读写规则

> **Linux方案**：一个管道允许**多个写进程**和**一个读进程**，或者**多个写进程**和**多个读进程**。

---

<a id="信号"></a>
## 五、信号

### 5.1 信号的概念

信号（Signal）是用于通知进程某个**特定事件已经发生**的机制。进程收到信号后进行相应处理。

### 5.2 信号的发送与保存

![信号发送](/assets/os-notes/Pasted%20image%2020260604211809.webp)

### 5.3 信号的处理时机

当进程从**内核态**转为**用户态**时，检查是否有待处理信号。

![信号处理时机](/assets/os-notes/Pasted%20image%2020260604212707.webp)

### 5.4 信号的处理方式

| 处理方式 | 说明 |
|----------|------|
| **默认处理** | 执行OS设置的缺省信号处理程序 |
| **自定义处理** | 用户注册的信号处理函数（覆盖默认） |
| **忽略** | 某些信号可以被忽略 |

### 5.5 信号处理规则

1. 处理完信号后，返回进程的下一条指令继续执行
2. 一旦处理了某个信号，pending位重置为0
3. 重复收到的同类信号被丢弃
4. 同时收到多个信号时，先处理序号更小的
5. 某些信号不能被自定义处理或阻塞（如SIGKILL、SIGSTOP）

---

<a id="linux"></a>
## 六、Linux实战：进程通信

### 6.1 管道通信

```bash
# 匿名管道（父子进程间）
ls | grep ".txt"

# 创建命名管道（任意进程间）
mkfifo /tmp/my_pipe

# 写入端
echo "Hello from writer" > /tmp/my_pipe &

# 读取端
cat /tmp/my_pipe

6.2 共享内存

# 使用ipcs查看共享内存
ipcs -m

# Python共享内存示例
python3 << 'EOF'
import multiprocessing
import time

def writer(shm):
    shm.buf[:5] = b'Hello'
    print("写入完成")

def reader(shm):
    time.sleep(1)
    print(f"读取: {bytes(shm.buf[:5])}")

if __name__ == '__main__':
    shm = multiprocessing.shared_memory.SharedMemory(create=True, size=1024)
    
    p1 = multiprocessing.Process(target=writer, args=(shm,))
    p2 = multiprocessing.Process(target=reader, args=(shm,))
    
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    
    shm.close()
    shm.unlink()
EOF

6.3 消息队列

# 查看消息队列
ipcs -q

# Python消息队列示例
python3 << 'EOF'
from multiprocessing import Queue, Process

def sender(q):
    q.put("Hello from sender")
    q.put(42)

def receiver(q):
    print(f"收到: {q.get()}")
    print(f"收到: {q.get()}")

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=sender, args=(q,))
    p2 = Process(target=receiver, args=(q,))
    p1.start()
    p1.join()
    p2.start()
    p2.join()
EOF

6.4 信号

# 查看所有信号
kill -l

# 发送信号
kill -SIGUSR1 <PID>    # 发送用户自定义信号
kill -SIGTERM <PID>    # 请求终止
kill -SIGKILL <PID>    # 强制终止

# Python信号处理
python3 << 'EOF'
import signal
import os

def handler(signum, frame):
    print(f"收到信号 {signum}")

signal.signal(signal.SIGUSR1, handler)

print(f"PID: {os.getpid()}")
print("等待信号 SIGUSR1...")
signal.pause()
EOF

6.5 Socket通信

# 服务器端
python3 -c "
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('localhost', 12345))
s.listen(1)
conn, addr = s.accept()
data = conn.recv(1024)
print(f'收到: {data.decode()}')
conn.send(b'Hello from server')
conn.close()
" &

# 客户端
python3 -c "
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('localhost', 12345))
s.send(b'Hello from client')
data = s.recv(1024)
print(f'收到: {data.decode()}')
s.close()
"

七、本章小结

核心概念

概念	要点
共享存储	开辟共享内存区，需要同步互斥
消息传递	发送/接收消息，直接或间接（信箱）
管道通信	共享文件连接，半双工，阻塞机制
信号	事件通知机制，内核态→用户态时处理

IPC方式对比

方式	速度	灵活性	适用场景
共享内存	最快	高	大量数据交换
消息传递	中等	最高	结构化通信
管道	较快	低	父子进程/单向数据流
信号	最快	低	事件通知

考研/期末常见考点

三种IPC方式的原理和特点
管道通信的5个特点（半双工、互斥、阻塞等）
直接通信 vs 间接通信
基于存储区 vs 基于数据结构的共享
信号的处理时机和规则

思考题

为什么共享存储需要同步互斥机制？
管道通信中，数据被读取后为什么就消失了？
直接通信和间接通信各有什么优缺点？

上一篇：OS笔记（三）：进程控制 下一篇：OS笔记（五）：线程

OS笔记（五）：线程

Fri, 05 Jun 2026 00:00:00 GMT

OS笔记（五）：线程

本文是操作系统笔记系列的第五篇，详细讲解线程的概念、用户级线程与内核级线程的区别、多线程模型，以及Linux中的线程管理。

📚 目录

一、线程的概念
二、线程的实现方式
三、多线程模型
四、线程的状态与控制
五、Linux实战：线程管理
六、本章小结

一、线程的概念

1.1 什么是线程？

线程（Thread）可以理解为轻量级进程。它是：

CPU执行的基本单位
程序执行流的最小单位

1.2 为什么引入线程？

问题	解决方案
进程切换开销大	线程切换开销小
进程并发度有限	同一进程的线程可以并发
进程间通信复杂	线程间可以直接共享数据

1.3 进程 vs 线程

对比项	进程	线程
本质	资源分配的基本单位	CPU执行的基本单位
资源	拥有独立的资源	几乎不拥有资源
切换开销	大（切换地址空间）	小（共享地址空间）
通信方式	需要IPC机制	直接读写共享变量
崩溃影响	不影响其他进程	可能导致整个进程崩溃

1.4 线程的属性

线程是处理机调度的单位
多CPU计算机中，各线程可占用不同的CPU
每个线程都有一个线程ID和TCB（线程控制块）
线程也有就绪、阻塞、运行三种基本状态
线程几乎不拥有系统资源
同一进程的线程共享进程资源
同一线程的线程通信无需系统干预
同一进程的线程切换不会引起进程切换
不同进程的线程切换会引起进程切换
切换同进程内线程的开销很小
切换进程的开销很大

二、线程的实现方式

2.1 用户级线程（User-Level Thread）

特点	说明
管理者	应用程序（线程库）
切换位置	用户态
OS感知	OS不知道线程存在

优点：

切换不需要切换到核心态，开销小、效率高

缺点：

一个线程阻塞会导致整个进程阻塞
无法利用多核CPU

2.2 内核级线程（Kernel-Level Thread）

特点	说明
管理者	操作系统内核
切换位置	核心态
OS感知	OS为每个线程建立TCB

优点：

一个线程阻塞不影响其他线程
可以利用多核CPU

缺点：

切换需要切换到核心态，开销大

2.3 用户级 vs 内核级

对比	用户级线程	内核级线程
切换开销	小	大
并发能力	弱	强
多核利用	不能	能
阻塞影响	整个进程阻塞	仅当前线程阻塞

重点：操作系统只能看到内核级线程！

三、多线程模型

3.1 一对一模型

一个用户级线程对应一个内核级线程。

优点	缺点
并发能力强	线程管理成本高

3.2 多对一模型

多个用户级线程对应一个内核级线程。

优点	缺点
切换开销小	并发性不好

3.3 多对多模型

多个用户级线程对应多个内核级线程。

优点	特点
兼顾并发性和开销	折中方案

3.4 模型对比

模型	用户级:内核级	并发性	开销
一对一	1:1	最强	最大
多对一	N:1	最弱	最小
多对多	N:M	较强	较小

四、线程的状态与控制

4.1 线程的状态

线程也有三种基本状态：

![线程状态](/assets/os-notes/Pasted%20image%2020260605180138.webp)

### 4.2 线程控制块（TCB）

TCB存储线程的信息：

| 信息 | 说明 |
|------|------|
| 线程ID | 唯一标识 |
| 程序计数器 | 下一条指令地址 |
| 寄存器值 | CPU寄存器状态 |
| 栈指针 | 线程栈的位置 |
| 线程状态 | 就绪/运行/阻塞 |

![线程组织](/assets/os-notes/Pasted%20image%2020260605180515.webp)

---

<a id="linux"></a>
## 五、Linux实战：线程管理

### 5.1 Linux中的线程

Linux中线程被称为**轻量级进程**（LWP），使用 `clone()` 系统调用创建。

### 5.2 查看线程

```bash
# 查看进程的线程
ps -T -p <PID>

# 查看所有线程
ps -eLf

# 使用top查看线程
top -H -p <PID>

# 使用htop（更直观）
htop -H

5.3 创建线程（C语言）

cat > thread_demo.c << 'EOF'
#include <stdio.h>
#include <pthread.h>

void* thread_func(void* arg) {
    printf("线程 %ld 运行中\n", (long)arg);
    return NULL;
}

int main() {
    pthread_t threads[3];
    
    // 创建3个线程
    for (long i = 0; i < 3; i++) {
        pthread_create(&threads[i], NULL, thread_func, (void*)i);
    }
    
    // 等待线程结束
    for (int i = 0; i < 3; i++) {
        pthread_join(threads[i], NULL);
    }
    
    printf("所有线程执行完毕\n");
    return 0;
}
EOF

gcc thread_demo.c -lpthread -o thread_demo
./thread_demo

5.4 创建线程（Python）

python3 << 'EOF'
import threading
import time

def worker(tid):
    print(f"线程 {tid} 开始")
    time.sleep(1)
    print(f"线程 {tid} 结束")

# 创建5个线程
threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()

print("所有线程执行完毕")
EOF

5.5 线程同步

python3 << 'EOF'
import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

# 创建10个线程并发修改共享变量
threads = []
for _ in range(10):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"最终计数: {counter}")  # 应该是1000000
EOF

5.6 线程vs进程性能对比

python3 << 'EOF'
import threading
import multiprocessing
import time

def task():
    sum(range(1000000))

# 测试线程
start = time.time()
threads = [threading.Thread(target=task) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()
thread_time = time.time() - start

# 测试进程
start = time.time()
processes = [multiprocessing.Process(target=task) for _ in range(4)]
for p in processes: p.start()
for p in processes: p.join()
process_time = time.time() - start

print(f"线程耗时: {thread_time:.3f}s")
print(f"进程耗时: {process_time:.3f}s")
EOF

5.7 查看线程详细信息

# 查看线程栈信息
cat /proc/<PID>/task/<TID>/stack

# 查看线程状态
cat /proc/<PID>/task/<TID>/status

# 使用pstack查看线程栈
pstack <PID>

六、本章小结

核心概念

概念	要点
线程	CPU执行的基本单位，轻量级进程
用户级线程	用户态切换，开销小，并发弱
内核级线程	核心态切换，开销大，并发强
一对一模型	并发强，开销大
多对一模型	并发弱，开销小
多对多模型	折中方案

线程实现方式对比

对比项	用户级线程	内核级线程
切换位置	用户态	核心态
OS感知	否	是
切换开销	小	大
并发能力	弱	强
多核利用	不能	能

考研/期末常见考点

线程和进程的区别
用户级线程和内核级线程的区别
三种多线程模型的特点和对比
OS只能看到内核级线程
线程切换和进程切换的开销对比

思考题

为什么说线程是"轻量级进程"？
用户级线程为什么不能利用多核CPU？
多对多模型是如何兼顾并发性和开销的？

上一篇：OS笔记（四）：进程通信 下一篇：OS笔记（六）：调度的概念、层次

OS笔记（六）：调度的概念、层次

Fri, 05 Jun 2026 00:00:00 GMT

OS笔记（六）：调度的概念、层次

本文是操作系统笔记系列的第六篇，详细讲解操作系统调度的三个层次（高级调度、中级调度、低级调度）以及七状态模型。

📚 目录

一、什么是调度？
二、调度的三个层次
三、三层调度的对比
四、七状态模型
五、Linux实战：调度管理
六、本章小结

一、什么是调度？

1.1 调度的定义

调度（Scheduling）是操作系统按照某种策略从多个可执行的候选中选择一个来使用某种资源的过程。

1.2 为什么需要调度？

CPU资源有限，进程数量多
需要决定哪个进程获得CPU
需要平衡公平性和效率

二、调度的三个层次

2.1 高级调度（作业调度）

作业：一个具体的任务（用户提交的工作单位）。

高级调度：按一定原则从外存的作业后备队列中挑选一个作业调入内存，并创建进程。

特点	说明
频率	每个作业只调入一次，调出一次
操作	调入时建立PCB，调出时撤销PCB
目标	控制内存中的进程数量

### 2.2 中级调度（内存调度）

**挂起状态**：内存不够时，将某些进程的数据调到外存等待。

**中级调度**：按照某种策略决定将哪个**挂起状态的进程**重新调入内存。

| 特点 | 说明 |
|------|------|
| **目的** | 提高内存利用率和系统吞吐量 |
| **操作** | 将挂起进程调入/调出内存 |
| **频率** | 比高级调度频繁 |

2.3 低级调度（进程调度）

低级调度：按照某种策略从就绪队列中选取一个进程，将处理机分配给它。

特点	说明
频率	最基本的一种调度，频率最高
操作	从就绪队列选择进程，分配CPU
必要性	一般OS中必须配置

---

<a id="对比"></a>
## 三、三层调度的对比

| 对比项 | 高级调度 | 中级调度 | 低级调度 |
|--------|----------|----------|----------|
| **别名** | 作业调度 | 内存调度 | 进程调度 |
| **调度对象** | 作业 | 挂起进程 | 就绪进程 |
| **位置** | 外存→内存 | 外存↔内存 | 就绪队列→CPU |
| **频率** | 最低 | 中等 | **最高** |
| **影响** | 控制并发度 | 内存利用率 | CPU利用率 |
| **是否存在** | 批处理系统 | 虚拟内存系统 | 所有OS |

---

<a id="七状态"></a>
## 四、七状态模型

在五状态模型的基础上，增加了**挂起就绪**和**挂起阻塞**两个状态。

![七状态模型](/assets/os-notes/Pasted%20image%2020260605193054.webp)

### 4.1 七种状态

| 状态 | 英文 | 含义 |
|------|------|------|
| **创建态** | New | 进程正在创建 |
| **就绪态** | Ready | 在内存中等待CPU |
| **运行态** | Running | 正在CPU上执行 |
| **阻塞态** | Blocked | 在内存中等待事件 |
| **终止态** | Terminated | 进程结束 |
| **挂起就绪态** | Ready Suspend | 在外存中，但已具备运行条件 |
| **挂起阻塞态** | Blocked Suspend | 在外存中，等待某事件 |

### 4.2 状态转换

4.3 挂起的作用

作用	说明
提高内存利用率	将不活跃进程调出内存
容纳更多进程	外存可以存放更多进程
系统负载调节	负载高时挂起低优先级进程

五、Linux实战：调度管理

5.1 Linux调度器

Linux使用CFS（Completely Fair Scheduler，完全公平调度器）：

特性	说明
基于虚拟运行时间	运行时间少的进程优先
红黑树组织	按虚拟运行时间排序
时间片动态分配	根据进程数量和优先级

5.2 查看调度信息

# 查看进程调度策略
chrt -p <PID>

# 查看进程优先级
ps -eo pid,ni,comm | head

# 查看调度类
cat /proc/<PID>/sched

5.3 调整进程优先级

# nice值范围：-20（最高）到 19（最低）
nice -n 10 ./my_program      # 以较低优先级启动
renice -5 -p <PID>            # 修改运行中进程的优先级

# 实时调度策略
chrt -f 50 ./my_program       # FIFO实时调度，优先级50
chrt -r 50 ./my_program       # Round-Robin实时调度

5.4 CPU亲和性

# 查看进程在哪个CPU上运行
taskset -p <PID>

# 绑定进程到特定CPU
taskset -c 0,1 <PID>          # 绑定到CPU 0和1
taskset -c 2 ./my_program     # 启动时绑定到CPU 2

5.5 查看系统调度统计

# 查看CPU调度统计
cat /proc/schedstat

# 使用mpstat查看CPU使用
mpstat -P ALL 1

# 使用pidstat查看进程调度
pidstat -p <PID> 1

5.6 查看进程状态

# 查看进程状态（R/S/D/Z/T）
ps aux | awk '{print $8}' | sort | uniq -c

# 统计各状态进程数
echo "运行中: $(ps aux | grep ' R ' | wc -l)"
echo "睡眠中: $(ps aux | grep ' S ' | wc -l)"
echo "僵尸态: $(ps aux | grep ' Z ' | wc -l)"

5.7 cgroup限制CPU

# 查看cgroup
ls /sys/fs/cgroup/cpu/

# 限制进程CPU使用（50%单核）
mkdir /sys/fs/cgroup/cpu/limited
echo 50000 > /sys/fs/cgroup/cpu/limited/cpu.cfs_quota_us
echo 100000 > /sys/fs/cgroup/cpu/limited/cpu.cfs_period_us
echo <PID> > /sys/fs/cgroup/cpu/limited/tasks

六、本章小结

核心概念

概念	要点
高级调度	外存→内存，作业级别，频率最低
中级调度	内存↔外存，挂起进程，提高内存利用率
低级调度	就绪队列→CPU，频率最高，最基本
七状态模型	五状态 + 挂起就绪 + 挂起阻塞

三层调度对比

对比项	高级调度	中级调度	低级调度
频率	低	中	高
位置	外存→内存	内存↔外存	就绪→CPU
目的	控制并发度	内存利用率	CPU利用率

考研/期末常见考点

三个层次调度的区别和联系
高级调度和低级调度的频率对比
七状态模型中挂起状态的作用
挂起就绪和挂起阻塞的区别
为什么低级调度是最基本的调度

思考题

高级调度和低级调度分别在什么时候发生？
七状态模型相比五状态模型多了什么？
挂起状态有什么作用？什么时候会触发挂起？

上一篇：OS笔记（五）：线程

Obsidian完全指南：从入门到精通的知识管理神器

Thu, 04 Jun 2026 00:00:00 GMT

Obsidian完全指南：从入门到精通的知识管理神器

本文约5000字，阅读时间约15分钟。适合零基础用户，也包含进阶同步方案和高级技巧。

一、Obsidian是什么？

1.1 为什么选择Obsidian？

在众多笔记软件中，Obsidian凭借其独特的理念脱颖而出：

本地存储：你的笔记就是普通的Markdown文件，存在你自己的设备上，不依赖任何云服务
双向链接：通过[[]]语法轻松建立笔记之间的关联，形成知识网络
图谱视图：可视化展示笔记之间的关系，让你看到知识的全貌
插件生态：超过1000+社区插件，几乎可以实现任何你想要的功能
完全免费：个人使用完全免费，付费的只是可选的云同步服务

1.2 Obsidian vs 其他笔记软件

特性	Obsidian	Notion	AFFiNE	语雀
存储方式	本地Markdown	云端	云端	云端
离线使用	✅ 完全支持	❌ 需联网	❌ 需联网	❌ 需联网
双向链接	✅ 核心功能	⚠️ 有限	⚠️ 有限	❌ 无
图谱视图	✅ 内置	❌ 无	❌ 无	❌ 无
插件扩展	✅ 1000+	❌ 无	❌ 无	❌ 无
数据所有权	✅ 完全掌控	❌ 平台托管	❌ 平台托管	❌ 平台托管
内存占用	~200MB	~500MB	~800MB	~300MB
价格	免费（个人）	免费/付费	免费	免费/付费

结论：如果你重视数据隐私、需要离线使用、喜欢折腾自定义，Obsidian是最佳选择。如果你需要团队协作、不想折腾，Notion可能更适合。

二、安装与初始设置

2.1 下载安装

Obsidian支持全平台：

Windows/macOS/Linux：访问 obsidian.md 下载安装包
Android/iOS：在应用商店搜索"Obsidian"下载
网页版：官方不提供，但可以通过服务器部署code-server实现

2.2 创建第一个Vault（仓库）

打开Obsidian，点击"Create new vault"
输入仓库名称（建议用英文，如"my-notes"）
选择存储位置（建议放在容易备份的位置）
点击"Create"完成创建

小贴士：一个Vault就是一个普通的文件夹，里面包含你的所有笔记（.md文件）和配置（.obsidian文件夹）。你可以随时用文件管理器打开它。

2.3 界面布局

Obsidian的界面主要分为：

左侧边栏：文件资源管理器、搜索、书签
中央区域：笔记编辑区（支持分屏）
右侧边栏：大纲、反向链接、图谱
底部状态栏：字数、阅读时间、当前模式

2.4 基础设置优化

进入设置（Ctrl+,），建议调整：

外观 → 基础颜色：根据喜好选择浅色/深色
编辑器 → 行号：开启
编辑器 → 显示当前行高亮：开启
文件与链接 → 默认新建笔记位置：选择"当前文件所在的文件夹"
文件与链接 → 使用Wiki链接：开启（推荐）

三、Markdown语法速查

Obsidian使用标准Markdown语法，并扩展了一些独特功能。

3.1 基础语法

# 一级标题
## 二级标题
### 三级标题

**加粗文本**
*斜体文本*
~~删除线~~
`行内代码`

- 无序列表
1. 有序列表
- [ ] 任务列表（未完成）
- [x] 任务列表（已完成）

> 引用块

---

| 表头1 | 表头2 |
|:---|:---|
| 单元格 | 单元格 |

3.2 Obsidian扩展语法

双向链接（核心功能）：

[[笔记标题]]          → 链接到其他笔记
[[笔记标题|显示文字]]  → 自定义显示文字
[[笔记标题#标题]]     → 链接到笔记的特定章节
![[图片.png]]         → 嵌入图片
![[笔记标题]]         → 嵌入整个笔记

标签：

#标签
#父标签/子标签

Callout提示框：

> [!note] 提示
> 这是一个提示框

> [!warning] 警告
> 这是一个警告框

> [!tip] 小贴士
> 这是一个小贴士

高亮：

==高亮文本==

数学公式：

行内公式：$E = mc^2$
块级公式：
$$
\sum_{i=1}^{n} x_i = x_1 + x_2 + ... + x_n
$$

四、插件系统：让Obsidian更强大

4.1 安装插件

设置 → 第三方插件 → 关闭"安全模式"
点击"浏览"进入社区插件市场
搜索并安装你需要的插件
启用插件并配置

4.2 必装插件推荐

效率提升类

插件名	功能	推荐理由
QuickAdd	快速添加笔记、模板	提高笔记效率
Templater	高级模板系统	自动化笔记结构
Calendar	日历视图	快速创建日记
Periodic Notes	周记/月记/年记	建立笔记习惯
Commander	自定义工具栏	提升操作效率

外观美化类

插件名	功能	推荐理由
Minimal Theme	简洁主题	最受欢迎的主题
Style Settings	主题自定义	微调主题细节
Hider	隐藏界面元素	极简界面
Icon Folder	文件夹图标	文件夹更直观
Custom Frames	嵌入网页	集成其他工具

知识管理类

插件名	功能	推荐理由
Dataview	数据查询	将笔记变成数据库
Excalidraw	手绘白板	可视化思考
Kanban	看板视图	项目管理
Mind Map	思维导图	自动生成导图
Outline	增强大纲	更好的导航

同步与发布类

插件名	功能	推荐理由
Remotely Save	云端同步	支持S3/WebDAV/坚果云
Git	Git同步	版本控制+同步
Syncthing	P2P同步	免费、无服务器
Obsidian Publish	官方发布	付费但简单
Quartz	静态站点生成	免费自托管

4.3 插件配置示例：Dataview

Dataview可以将你的笔记变成数据库：

// 列出所有未完成的任务
TASK
WHERE !completed
LIMIT 10

// 列出最近修改的笔记
TABLE file.mtime AS "修改时间"
FROM ""
SORT file.mtime DESC
LIMIT 10

// 统计每个标签的笔记数量
TABLE length(rows) AS "数量"
FROM #标签
GROUP BY tags

五、多设备同步方案

这是很多用户最关心的问题。下面介绍几种主流方案。

5.1 方案对比

方案	价格	难度	多平台	自动同步	推荐场景
Obsidian Sync	$8/月	⭐	✅	✅	懒人、预算充足
Remotely Save + 坚果云	免费	⭐⭐	✅	✅	国内用户首选
Git + GitHub	免费	⭐⭐⭐	✅	⚠️ 需手动	程序员
Syncthing	免费	⭐⭐⭐	✅	✅	注重隐私
服务器中转	免费	⭐⭐⭐⭐	✅	✅	有服务器的用户

5.2 方案一：Remotely Save + 坚果云（推荐国内用户）

原理：通过WebDAV协议将笔记同步到坚果云。

步骤：

注册坚果云账号
在坚果云中创建应用：
- 设置 → 安全选项 → 第三方应用管理
- 添加应用，获取密码
在Obsidian中安装"Remotely Save"插件

配置插件：

Remote Service: WebDAV
Server Address: https://dav.jianguoyun.com/dav/
Username: 你的坚果云邮箱
Password: 第三方应用密码

点击"Check"测试连接
开启"自动同步"

优点：免费、稳定、国内速度快缺点：坚果云免费版有流量限制（1GB/月上传，3GB/月下载）

5.3 方案二：Git + GitHub（程序员首选）

原理：将笔记仓库用Git管理，推送到GitHub。

步骤：

在GitHub创建私有仓库
在Obsidian安装"Git"插件

配置插件：

Auto pull interval: 5
Auto push interval: 5
Pull updates on startup: 开启
Push on backup: 开启

初始化仓库并推送：

打开命令面板（Ctrl+P）
输入 "Git: Initialize git repository"
输入 "Git: commit all changes"
输入 "Git: push"

优点：免费、有版本历史、可回滚缺点：需要Git知识、同步有延迟

5.4 方案三：Syncthing（注重隐私）

原理：P2P直接同步，不经过任何服务器。

步骤：

在所有设备安装Syncthing
添加设备（扫描二维码或输入设备ID）
共享笔记文件夹
等待同步完成

优点：完全免费、无流量限制、隐私安全缺点：需要设备同时在线、初次配置复杂

5.5 方案四：服务器中转（有服务器的用户）

原理：在服务器上部署同步服务，所有设备连接到服务器。

方案A：Gitea + Git插件

如果你有Gitea服务器（端口3000），可以：

在Gitea创建私有仓库
配置Git插件指向Gitea服务器
享受免费的私有同步

方案B：code-server + Foam

如果你想在任何设备上通过浏览器使用Obsidian：

在服务器安装code-server
安装Foam插件（VS Code的Obsidian替代）
通过浏览器访问 http://服务器IP:8080

优点：随时随地访问、数据完全掌控缺点：需要服务器、带宽有限（如3M带宽）

六、高级技巧

6.1 模板系统

使用Templater插件创建模板：

---
title: <% tp.file.title %>
date: <% tp.date.now("YYYY-MM-DD") %>
tags: [日记]
---

# <% tp.file.title %>

## 今日目标
- [ ] 

## 今日记录

## 今日总结

## 明日计划
- [ ]

将模板放入模板文件夹，然后通过命令面板插入。

6.2 Dataview进阶

创建动态笔记索引：

TABLE file.ctime AS "创建时间", file.size AS "大小"
FROM ""
WHERE file.folder = "项目"
SORT file.ctime DESC

统计字数：

TABLE length(file.content) AS "字数"
FROM ""
SORT length(file.content) DESC
LIMIT 10

任务看板：

TASK
WHERE contains(text, "#重要") AND !completed
GROUP BY file.link

6.3 快捷键自定义

进入设置 → 快捷键，建议自定义：

Ctrl+N：新建笔记
Ctrl+O：快速打开
Ctrl+P：命令面板
Ctrl+E：切换编辑/预览模式
Ctrl+Shift+F：全局搜索
Ctrl+G：图谱视图

6.4 笔记组织策略

PARA方法：

Projects：当前进行的项目
Areas：持续关注的领域
Resources：感兴趣的资源
Archives：已完成或不再活跃的内容

Zettelkasten卡片盒笔记法：

每个笔记只写一个想法
用自己的话重新表述
通过双向链接建立关联
定期回顾和整理

七、常见问题解答

Q1：Obsidian免费吗？

A：完全免费！付费的只是可选的云同步服务（Obsidian Sync，$8/月）和官方发布服务（Obsidian Publish，$16/月）。所有核心功能和插件都是免费的。

Q2：笔记存在哪里？

A：存在你选择的本地文件夹中，就是普通的.md文件。你可以随时用其他编辑器打开，也可以用文件管理器备份。

Q3：如何备份？

A：

简单备份：直接复制整个Vault文件夹
Git备份：用Git管理，推送到GitHub/Gitea
云备份：用Syncthing或坚果云自动同步

Q4：插件安全吗？

A：社区插件都是开源的，代码可在GitHub查看。但建议只安装知名插件，避免安装来源不明的插件。

Q5：Obsidian和AFFiNE哪个好？

A：取决于你的需求：

Obsidian：本地优先、插件丰富、适合个人知识管理
AFFiNE：云端优先、界面现代、适合团队协作

如果你是个人用户，且重视数据隐私，推荐Obsidian。如果你的服务器内存有限（如3.6GB），AFFiNE可能会比较吃力。

八、学习资源

官方资源

中文社区

九、总结

Obsidian不仅仅是一个笔记软件，它是一个知识管理系统。通过双向链接、图谱视图和丰富的插件生态，你可以构建一个真正属于自己的"第二大脑"。

入门建议：

先用基础功能，不要一开始就折腾插件
养成每日记录的习惯
慢慢建立笔记之间的链接
定期回顾和整理

进阶建议：

学习Dataview，将笔记变成数据库
使用模板系统，提高效率
选择适合自己的同步方案
探索社区插件，扩展功能

记住，工具只是手段，真正重要的是你的思考和记录。Obsidian提供了一个强大的平台，但最终的价值来自于你持续的输入和整理。

关于作者：本文由火花花博客整理，如有问题欢迎在评论区留言。

相关文章推荐：

Linux操作大全（十一）：Git版本控制完全指南

Tue, 26 May 2026 00:00:00 GMT

Linux操作大全（十一）：Git版本控制完全指南

本篇是Linux操作大全的第十一篇，专门讲解Git版本控制系统的使用。

📚 目录

Git简介与安装
Git基础配置
创建仓库
基本工作流程
分支管理
远程仓库操作
标签管理
查看历史与差异
撤销与回退
Git高级技巧
常见问题与解决方案
Git命令速查表

1. Git简介与安装

1.1 什么是Git？

Git是一个分布式版本控制系统，用于跟踪文件的变化，协调多人协作开发。

核心特点：

分布式：每个开发者都有完整的仓库副本
快照式：每次提交都是项目的完整快照
分支轻量：创建和切换分支几乎瞬间完成
数据完整：使用SHA-1哈希保证数据完整性

1.2 安装Git

Ubuntu/Debian:

sudo apt update
sudo apt install git

CentOS/RHEL:

sudo yum install git

macOS:

# 使用Homebrew
brew install git

验证安装:

git --version
# 输出示例：git version 2.39.2

2. Git基础配置

2.1 用户信息配置

设置用户名和邮箱（必须配置）：

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

查看配置：

git config --list
git config user.name
git config user.email

2.2 配置级别

Git配置分为三个级别：

级别	命令参数	配置文件位置	作用范围
系统级	`--system`	`/etc/gitconfig`	所有用户
全局级	`--global`	`~/.gitconfig`	当前用户
仓库级	`--local`	`.git/config`	当前仓库

示例：

# 全局配置（推荐）
git config --global user.name "Emilia"

# 仓库级配置（覆盖全局）
git config --local user.name "Project Name"

2.3 常用配置项

# 设置默认编辑器
git config --global core.editor vim

# 设置默认分支名
git config --global init.defaultBranch main

# 启用颜色输出
git config --global color.ui auto

# 设置换行符处理（Windows用户）
git config --global core.autocrlf true

# 设置换行符处理（Linux/Mac用户）
git config --global core.autocrlf input

# 设置pull时使用rebase
git config --global pull.rebase true

# 设置推送时推送当前分支
git config --global push.default current

3. 创建仓库

3.1 初始化新仓库

# 创建项目目录并初始化
mkdir my-project
cd my-project
git init

# 或者在当前目录初始化
git init

初始化后会创建 .git 目录，包含所有版本控制信息。

3.2 克隆远程仓库

# HTTPS克隆
git clone https://github.com/user/repo.git

# SSH克隆（推荐）
git clone git@github.com:user/repo.git

# 克隆到指定目录
git clone https://github.com/user/repo.git my-folder

# 克隆特定分支
git clone -b develop https://github.com/user/repo.git

# 浅克隆（只克隆最近一次提交）
git clone --depth 1 https://github.com/user/repo.git

3.3 仓库结构

Git仓库包含三个主要区域：

工作区 (Working Directory)
    ↓ git add
暂存区 (Staging Area / Index)
    ↓ git commit
本地仓库 (Local Repository)
    ↓ git push
远程仓库 (Remote Repository)

4. 基本工作流程

4.1 查看状态

# 查看工作区状态
git status

# 简洁模式
git status -s
git status --short

# 输出示例：
# M file.txt      # 已修改（未暂存）
# A new.txt       # 新添加（已暂存）
# ?? other.txt    # 未跟踪

4.2 添加到暂存区

# 添加单个文件
git add file.txt

# 添加多个文件
git add file1.txt file2.txt

# 添加所有修改和新文件
git add .

# 添加所有文件（包括删除）
git add -A

# 交互式添加
git add -p
# 然后选择要添加的代码块

4.3 提交更改

# 提交并添加消息
git commit -m "feat: 添加新功能"

# 添加消息的详细描述
git commit -m "feat: 添加用户登录功能" -m "包含密码加密和记住登录状态"

# 自动暂存已跟踪文件的修改并提交
git commit -am "fix: 修复bug"

# 修改最后一次提交
git commit --amend

# 修改最后一次提交的消息
git commit --amend -m "新的提交消息"

4.4 提交消息规范

推荐使用约定式提交（Conventional Commits）：

<类型>(<范围>): <描述>

[可选正文]

[可选脚注]

常用类型：

feat: 新功能
fix: 修复bug
docs: 文档更新
style: 代码格式调整
refactor: 重构
perf: 性能优化
test: 测试相关
chore: 构建/工具相关

示例：

feat(auth): 添加用户登录功能

- 实现密码加密存储
- 添加记住登录状态选项
- 优化错误提示信息

Closes #123

5. 分支管理

5.1 分支基础

# 查看本地分支
git branch

# 查看所有分支（包括远程）
git branch -a

# 查看分支最后提交
git branch -v

# 创建新分支
git branch feature-login

# 切换分支
git checkout feature-login

# 创建并切换到新分支（推荐）
git checkout -b feature-login

# 或使用新命令（Git 2.23+）
git switch feature-login
git switch -c feature-login

5.2 分支操作

# 重命名分支
git branch -m old-name new-name

# 重命名当前分支
git branch -m new-name

# 删除本地分支
git branch -d feature-login

# 强制删除未合并的分支
git branch -D feature-login

# 删除远程分支
git push origin --delete feature-login

# 设置上游分支
git branch --set-upstream-to=origin/main main

5.3 分支策略

Git Flow 模型：

main (生产分支)
  │
  ├── develop (开发分支)
  │     │
  │     ├── feature/* (功能分支)
  │     ├── release/* (发布分支)
  │     └── hotfix/* (热修复分支)
  │
  └── v1.0, v2.0 (标签)

GitHub Flow 模型（推荐）：

main (主分支，始终可部署)
  │
  └── feature-* (功能分支，合并后删除)

5.4 合并分支

# 合并分支到当前分支
git merge feature-login

# 合并并创建合并提交
git merge --no-ff feature-login

# 中止合并（出现冲突时）
git merge --abort

5.5 变基

# 将当前分支变基到目标分支
git rebase main

# 交互式变基（整理提交历史）
git rebase -i HEAD~3
# 在编辑器中选择操作：pick, squash, reword, edit, drop

# 继续变基（解决冲突后）
git rebase --continue

# 中止变基
git rebase --abort

变基 vs 合并：

变基：创建线性历史，更清晰
合并：保留完整历史，更安全

6. 远程仓库操作

6.1 远程仓库管理

# 查看远程仓库
git remote

# 查看远程仓库详细信息
git remote -v

# 添加远程仓库
git remote add origin https://github.com/user/repo.git

# 修改远程仓库URL
git remote set-url origin https://github.com/user/new-repo.git

# 删除远程仓库
git remote remove origin

# 重命名远程仓库
git remote rename origin upstream

6.2 推送与拉取

# 推送到远程
git push origin main

# 推送并设置上游分支
git push -u origin main

# 推送所有分支
git push --all origin

# 推送标签
git push origin tag v1.0.0

# 推送所有标签
git push origin --tags

# 拉取远程更新
git pull origin main

# 拉取并变基
git pull --rebase origin main

# 获取远程更新（不合并）
git fetch origin

# 获取所有远程更新
git fetch --all

6.3 多远程仓库

# 添加多个远程仓库
git remote add origin https://github.com/user/repo.git
git remote add upstream https://github.com/original/repo.git

# 从上游拉取更新
git fetch upstream

# 合并上游更改
git merge upstream/main

# 推送到不同远程
git push origin main
git push upstream main

7. 标签管理

7.1 标签类型

轻量标签（Lightweight Tag）：

git tag v1.0.0

附注标签（Annotated Tag）：

git tag -a v1.0.0 -m "版本 1.0.0 发布"

7.2 标签操作

# 查看所有标签
git tag

# 查看特定标签信息
git show v1.0.0

# 创建标签
git tag v1.0.0

# 创建附注标签
git tag -a v1.0.0 -m "Release v1.0.0"

# 给特定提交打标签
git tag -a v1.0.0 abc1234 -m "Release v1.0.0"

# 推送标签到远程
git push origin v1.0.0

# 推送所有标签
git push origin --tags

# 删除本地标签
git tag -d v1.0.0

# 删除远程标签
git push origin --delete v1.0.0

8. 查看历史与差异

8.1 查看提交历史

# 基本日志
git log

# 单行显示
git log --oneline

# 图形化显示
git log --graph --oneline --all

# 显示最近n次提交
git log -5

# 显示特定文件的历史
git log file.txt

# 显示某个作者的提交
git log --author="Emilia"

# 显示特定日期范围的提交
git log --after="2026-01-01" --before="2026-05-26"

# 显示提交的详细变更
git log -p

# 显示统计信息
git log --stat

8.2 查看差异

# 工作区与暂存区的差异
git diff

# 暂存区与最新提交的差异
git diff --staged
git diff --cached

# 两个提交之间的差异
git diff commit1 commit2

# 两个分支之间的差异
git diff main feature

# 显示特定文件的差异
git diff file.txt

# 显示统计信息
git diff --stat

8.3 搜索

# 搜索代码内容
git grep "function name"

# 搜索特定提交中的代码
git grep "function" v1.0.0

# 搜索引入特定字符串的提交
git log -S "function_name"

# 搜索正则表达式
git grep -E "func.*name"

9. 撤销与回退

9.1 撤销工作区修改

# 撤销单个文件的修改
git checkout -- file.txt

# 撤销所有修改
git checkout -- .

# 使用新命令（Git 2.23+）
git restore file.txt
git restore .

9.2 取消暂存

# 取消暂存文件
git reset HEAD file.txt

# 使用新命令
git restore --staged file.txt

9.3 回退提交

# 回退到指定提交，保留修改在暂存区
git reset --soft HEAD~1

# 回退到指定提交，保留修改在工作区
git reset --mixed HEAD~1

# 回退到指定提交，丢弃所有修改
git reset --hard HEAD~1

# 回退到特定提交
git reset --hard abc1234

9.4 安全回退

# 创建新提交来撤销指定提交
git revert HEAD

# 撤销指定提交
git revert abc1234

# 撤销多个提交
git revert HEAD~3..HEAD

# 不自动提交，只暂存
git revert --no-commit HEAD

9.5 恢复删除的提交

# 查看操作历史
git reflog

# 恢复到指定操作
git reset --hard HEAD@{2}

# 恢复删除的分支
git checkout -b recovered-branch HEAD@{5}

10. Git高级技巧

10.1 暂存工作

# 暂存当前修改
git stash

# 暂存并添加描述
git stash push -m "正在开发的功能"

# 暂存特定文件
git stash push file.txt

# 查看暂存列表
git stash list

# 恢复最近的暂存
git stash pop

# 恢复但不删除暂存
git stash apply

# 恢复特定暂存
git stash apply stash@{2}

# 删除暂存
git stash drop stash@{0}

# 清空所有暂存
git stash clear

10.2 Cherry-pick

# 选择特定提交应用到当前分支
git cherry-pick abc1234

# 选择多个提交
git cherry-pick commit1 commit2

# 选择提交范围
git cherry-pick commit1..commit5

# 不自动提交
git cherry-pick --no-commit abc1234

10.3 子模块

# 添加子模块
git submodule add https://github.com/user/repo.git path/to/submodule

# 初始化子模块
git submodule init

# 更新子模块
git submodule update

# 克隆包含子模块的仓库
git clone --recursive https://github.com/user/repo.git

# 或者克隆后初始化
git clone https://github.com/user/repo.git
git submodule init
git submodule update

10.4 Git钩子

Git钩子位于 .git/hooks/ 目录，常用钩子：

钩子名	触发时机	常见用途
`pre-commit`	提交前	代码检查、测试
`commit-msg`	提交时	验证提交消息格式
`pre-push`	推送前	运行测试
`post-merge`	合并后	安装依赖

示例：pre-commit钩子

#!/bin/bash
# .git/hooks/pre-commit

# 运行代码检查
npm run lint

# 如果检查失败，阻止提交
if [ $? -ne 0 ]; then
    echo "代码检查失败，请修复后再提交"
    exit 1
fi

10.5 大文件处理

# 安装Git LFS
git lfs install

# 跟踪大文件类型
git lfs track "*.psd"
git lfs track "*.zip"

# 查看跟踪的文件类型
git lfs ls-files

# 提交.gitattributes
git add .gitattributes
git commit -m "chore: 添加LFS跟踪规则"

11. 常见问题与解决方案

11.1 合并冲突

解决步骤：

执行合并/变基
查看冲突文件：git status
编辑冲突文件，解决冲突标记
添加解决后的文件：git add file.txt
完成合并：git commit 或 git rebase --continue

冲突标记：

<<<<<<< HEAD
当前分支的内容
=======
要合并的分支的内容
>>>>>>> feature-branch

11.2 误删文件恢复

# 恢复删除的文件
git checkout HEAD -- file.txt

# 或者
git restore --source=HEAD file.txt

11.3 修改历史提交

# 交互式变基（修改最近3次提交）
git rebase -i HEAD~3

# 修改作者信息
git commit --amend --author="Name <email>"

# 修改全局历史（谨慎使用）
git filter-branch --env-filter '
if [ "$GIT_AUTHOR_EMAIL" = "old@email.com" ]; then
    export GIT_AUTHOR_EMAIL="new@email.com"
fi
' --tag-name-filter cat -- --all

11.4 清理仓库

# 查看要删除的文件
git clean -n

# 删除未跟踪的文件
git clean -f

# 删除未跟踪的目录
git clean -fd

# 删除未跟踪和忽略的文件
git clean -fx

12. Git命令速查表

12.1 基础命令

命令	说明
`git init`	初始化新仓库
`git clone <url>`	克隆远程仓库
`git add <file>`	添加文件到暂存区
`git commit -m "msg"`	提交更改
`git status`	查看状态
`git diff`	查看差异
`git log`	查看历史

12.2 分支命令

命令	说明
`git branch`	列出分支
`git branch <name>`	创建分支
`git checkout <branch>`	切换分支
`git checkout -b <branch>`	创建并切换分支
`git merge <branch>`	合并分支
`git branch -d <branch>`	删除分支

12.3 远程命令

命令	说明
`git remote add <name> <url>`	添加远程仓库
`git push <remote> <branch>`	推送到远程
`git pull <remote> <branch>`	拉取远程更新
`git fetch <remote>`	获取远程更新

12.4 撤销命令

命令	说明
`git checkout -- <file>`	撤销工作区修改
`git reset HEAD <file>`	取消暂存
`git reset --soft HEAD~1`	回退提交（保留修改）
`git reset --hard HEAD~1`	回退提交（丢弃修改）
`git revert <commit>`	安全回退

12.5 高级命令

命令	说明
`git stash`	暂存工作
`git cherry-pick <commit>`	选择提交
`git rebase <branch>`	变基
`git tag <name>`	创建标签
`git reflog`	查看操作历史

📖 实用配置推荐

全局配置模板

# ~/.gitconfig

[user]
    name = Your Name
    email = your.email@example.com

[core]
    editor = vim
    autocrlf = input

[alias]
    st = status
    co = checkout
    br = branch
    ci = commit
    lg = log --graph --oneline --all
    last = log -1 HEAD
    unstage = reset HEAD --

[pull]
    rebase = true

[push]
    default = current

[color]
    ui = auto

常用别名设置

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.lg "log --graph --oneline --all"
git config --global alias.last "log -1 HEAD"
git config --global alias.unstage "reset HEAD --"

🔗 相关资源

📚 下一篇预告：Linux操作大全（十二）：Shell脚本编程进阶

🔙 返回：Linux操作大全目录

📖 配套速查：Linux命令速查手册

Linux操作大全（一）：基础入门完全指南

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（一）：基础入门完全指南

本文是Linux操作大全系列的第一篇，从最基础的概念讲起，让完全没有Linux经验的同学也能看懂、学会、直接用。

一、什么是Linux？

1.1 Linux的定义

Linux是一个开源的、免费的操作系统内核，由芬兰程序员**林纳斯·托瓦兹（Linus Torvalds）**在1991年首次发布。

简单来说：

操作系统 = 管理电脑硬件和软件的"大管家"
内核 = 操作系统最核心的部分，直接和硬件打交道
开源 = 源代码公开，任何人都可以查看、修改、分发

1.2 Linux和Windows的区别

特性	Windows	Linux
价格	需要付费购买授权	完全免费
源代码	闭源，微软独有	开源，全球开发者共同维护
使用方式	主要用图形界面（鼠标点点点）	主要用命令行（敲键盘）
病毒	容易中病毒	几乎没有病毒
定制性	不能修改系统底层	可以随意修改任何部分
应用场景	个人电脑、办公	服务器、嵌入式、超级计算机

1.3 为什么要学Linux？

1. 服务器领域霸主

全球90%以上的服务器运行Linux
阿里云、腾讯云、AWS等云服务器默认都是Linux
学会Linux才能做后端开发、运维、DevOps

2. 开发者必备技能

大部分开发工具在Linux上运行更好
Docker、Kubernetes等容器技术基于Linux
很多开源项目只支持Linux

3. 薪资优势

会Linux的开发者平均薪资更高
运维工程师、DevOps工程师必须精通Linux

4. 免费且自由

不用花钱买系统
可以自由定制，不受厂商限制

二、Linux发行版介绍

2.1 什么是发行版？

Linux内核本身只是"心脏"，要让它能用，还需要搭配各种软件（桌面环境、浏览器、办公软件等）。不同的组织把Linux内核 + 各种软件打包在一起，就形成了不同的"发行版"（Distribution，简称distro）。

就像安卓系统，华为、小米、OPPO都用安卓内核，但各自做了不同的定制UI。

2.2 主流发行版对比

Ubuntu（推荐新手使用）

特点：最流行的桌面Linux，社区活跃，教程多
适合：Linux入门、日常办公、开发
包管理：apt（基于Debian）
官网：https://ubuntu.com

CentOS / Rocky Linux

特点：企业级服务器系统，稳定可靠
适合：服务器部署、生产环境
包管理：yum / dnf（基于Red Hat）
注意：CentOS已停止维护，推荐使用Rocky Linux替代

Debian

特点：Ubuntu的"父亲"，极其稳定
适合：服务器、追求稳定的用户
包管理：apt

Arch Linux

特点：滚动更新，软件最新，需要自己配置一切
适合：高级用户、喜欢折腾的人
包管理：pacman

Fedora

特点：Red Hat的"试验田"，新技术尝鲜
适合：开发者、喜欢新功能的用户
包管理：dnf

2.3 新手推荐选择

如果你是纯新手：选 Ubuntu 22.04 LTS 或 Ubuntu 24.04 LTS

LTS = Long Term Support（长期支持版），有5年更新
教程最多，遇到问题容易搜到解决方案
界面友好，接近Windows的使用习惯

如果你要做服务器：选 Rocky Linux 9 或 Ubuntu Server 22.04

三、安装Linux

3.1 安装方式选择

方式	优点	缺点	适合场景
虚拟机	不影响现有系统，安全	性能有损耗	学习、测试
双系统	性能好，真实体验	需要分区，有风险	想长期使用Linux
WSL2	Windows内置，方便	不是完整Linux体验	Windows开发
云服务器	远程访问，24小时运行	需要付费	部署项目
树莓派	便宜，真实硬件	性能有限	嵌入式学习

3.2 虚拟机安装（推荐新手）

步骤1：下载VirtualBox

VirtualBox是免费的虚拟机软件，下载地址： https://www.virtualbox.org/

步骤2：下载Ubuntu镜像

到Ubuntu官网下载ISO文件： https://ubuntu.com/download/desktop

选择 Ubuntu 24.04 LTS，文件约4GB。

步骤3：创建虚拟机

打开VirtualBox，点击"新建"
名称输入"Ubuntu"，类型选"Linux"，版本选"Ubuntu (64-bit)"
内存建议分配 4096MB（4GB）以上
硬盘选择"创建虚拟硬盘"，大小建议 50GB 以上
硬盘类型选"VDI"，存储方式选"动态分配"

步骤4：安装Ubuntu

选中创建好的虚拟机，点击"设置" → "存储"
在"控制器:IDE"下，点击光盘图标，选择下载好的ISO文件
启动虚拟机，会自动进入Ubuntu安装界面
选择"Install Ubuntu"
语言选"中文（简体）"
键盘布局选"English (US)"
安装类型选"正常安装"，勾选"安装第三方软件"
安装类型选"清除整个磁盘并安装Ubuntu"（这只会清除虚拟机的虚拟硬盘，不影响真实系统）
设置用户名和密码
等待安装完成，重启即可

3.3 WSL2安装（Windows用户推荐）

WSL2（Windows Subsystem for Linux 2）是微软官方的Linux子系统，不用虚拟机就能在Windows上运行Linux。

步骤1：开启WSL功能

以管理员身份打开PowerShell，运行：

wsl --install

如果报错，手动开启功能：

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

重启电脑后，设置WSL2为默认版本：

wsl --set-default-version 2

步骤2：安装Ubuntu

打开Microsoft Store，搜索"Ubuntu"，选择 Ubuntu 24.04 LTS，点击"获取"安装。

安装完成后，从开始菜单打开Ubuntu，设置用户名和密码即可。

3.4 云服务器购买

如果你想长期使用Linux，或者要部署项目，建议购买云服务器。

购买建议

配置：2核2G内存足够学习用
系统：选择Ubuntu 22.04 LTS
地域：选离你近的地区（如华东、华南）
带宽：1-3Mbps足够

四、Linux桌面环境

4.1 什么是桌面环境？

桌面环境（Desktop Environment，简称DE）就是Linux的图形界面，包括：

窗口管理器（拖动、缩放窗口）
任务栏（显示打开的程序）
文件管理器（浏览文件）
系统设置（改壁纸、调音量等）

4.2 主流桌面环境

GNOME（Ubuntu默认）

特点：现代、简洁、动画流畅
缺点：占用资源较多，定制性一般
适合：喜欢简洁风格的用户

KDE Plasma

特点：功能强大，高度可定制，像Windows
缺点：选项太多，新手容易迷糊
适合：喜欢折腾、追求个性化的用户

XFCE

特点：轻量、快速、稳定
缺点：界面较老，不够美观
适合：老旧电脑、追求性能的用户

LXQt

特点：最轻量，资源占用极低
缺点：功能较少
适合：配置很低的电脑

4.3 如何切换桌面环境？

安装其他桌面环境：

# 安装KDE Plasma
sudo apt install kde-plasma-desktop

# 安装XFCE
sudo apt install xfce4

# 安装LXQt
sudo apt install lxqt

安装完成后，注销账户，在登录界面点击右下角的齿轮图标，选择想用的桌面环境。

五、Linux目录结构

5.1 为什么重要？

在Windows中，我们习惯C盘、D盘、E盘分开存放文件。但在Linux中，所有东西都在一个根目录 / 下，像一棵倒着的树。

理解目录结构是学好Linux的基础！

5.2 核心目录详解

/                    # 根目录，所有目录的起点
├── bin/             # 基础命令（ls, cp, mv等）
├── sbin/            # 系统管理命令（需要root权限）
├── etc/             # 配置文件（非常重要！）
│   ├── hostname     # 主机名
│   ├── hosts        # IP与主机名映射
│   ├── passwd       # 用户信息
│   ├── shadow       # 用户密码（加密）
│   ├── fstab        # 磁盘挂载配置
│   └── ssh/         # SSH配置
├── home/            # 用户目录（你的文件都在这里）
│   └── ubuntu/      # 用户ubuntu的家目录
│       ├── Desktop/ # 桌面
│       ├── Documents/# 文档
│       ├── Downloads/# 下载
│       └── ...      # 其他个人目录
├── root/            # root用户的家目录
├── var/             # 可变数据
│   ├── log/         # 日志文件
│   ├── www/         # 网站文件
│   └── lib/         # 程序数据
├── tmp/             # 临时文件（重启后清空）
├── usr/             # 用户程序
│   ├── bin/         # 用户命令
│   ├── lib/         # 库文件
│   └── share/       # 共享数据
├── opt/             # 第三方软件
├── proc/            # 进程信息（虚拟文件系统）
├── dev/             # 设备文件
│   ├── sda          # 第一块硬盘
│   ├── sdb          # 第二块硬盘
│   └── tty          # 终端设备
├── mnt/             # 临时挂载点
├── media/           # 自动挂载点（U盘、光盘）
├── boot/            # 启动文件
├── lib/             # 系统库文件
└── srv/             # 服务数据

5.3 重点目录记忆口诀

/etc → 配置文件放这里（"etc"= etcetera，意思是"等等"，杂七杂八的配置）
/home → 你的家，文件都放这里
/var → 日志、网站数据放这里（"var"= variable，可变数据）
/tmp → 临时文件放这里（重启就没了）
/usr → 安装的软件放这里（"usr"= Unix System Resources）
/bin → 基础命令放这里（"bin"= binary，二进制文件）

六、第一次使用Linux

6.1 打开终端

在Linux中，终端（Terminal） 是最重要的工具，相当于Windows的CMD或PowerShell。

打开终端的方式：

快捷键：Ctrl + Alt + T（Ubuntu默认）
右键桌面：选择"打开终端"
应用菜单：搜索"终端"

6.2 认识命令提示符

打开终端后，你会看到类似这样的内容：

ubuntu@ubuntu-desktop:~$

各部分含义：

ubuntu → 当前用户名
@ → 分隔符
ubuntu-desktop → 主机名
: → 分隔符
~ → 当前目录（~ 表示家目录）
$ → 普通用户提示符（root用户是 #）

6.3 第一个命令：查看当前目录

pwd

pwd = Print Working Directory（打印工作目录）

输出示例：

/home/ubuntu

这表示你当前在 /home/ubuntu 目录下。

6.4 第二个命令：查看目录内容

ls

ls = list（列出）

输出示例：

Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos

这是你家目录下的默认文件夹。

6.5 第三个命令：切换目录

cd Documents

cd = Change Directory（切换目录）

现在你进入了 Documents 目录。再输入：

pwd

输出：

/home/ubuntu/Documents

返回上一级目录：

cd ..

返回家目录：

cd ~
# 或者直接
cd

6.6 第四个命令：创建文件

touch test.txt

touch 命令会创建一个空文件。用 ls 验证：

ls

会看到多了 test.txt。

6.7 第五个命令：查看文件内容

cat test.txt

cat = concatenate（连接），用于查看文件内容。因为文件是空的，所以没有输出。

往文件里写点东西：

echo "Hello Linux!" > test.txt

echo 是输出文字的命令，> 是重定向符号，把输出写入文件。

再查看：

cat test.txt

输出：

Hello Linux!

七、常用快捷键

7.1 终端快捷键

快捷键	功能
`Ctrl + C`	终止当前命令
`Ctrl + D`	退出终端/输入结束
`Ctrl + L`	清屏（等同于clear命令）
`Ctrl + A`	光标移到行首
`Ctrl + E`	光标移到行尾
`Ctrl + U`	删除光标前的内容
`Ctrl + K`	删除光标后的内容
`Ctrl + W`	删除前一个单词
`Ctrl + R`	搜索历史命令
`Tab`	自动补全命令/路径
`↑` / `↓`	浏览历史命令

7.2 系统快捷键

快捷键	功能
`Ctrl + Alt + T`	打开终端
`Ctrl + Alt + F1~F6`	切换到文字终端
`Ctrl + Alt + F7`	切换回图形界面
`Super + D`	显示桌面
`Alt + Tab`	切换窗口
`PrtSc`	截图

八、帮助命令

8.1 man命令 <a id="man"></a>

man = manual（手册），是Linux自带的详细帮助文档。

man ls

会显示 ls 命令的完整手册，包括所有参数、用法、示例。

按 空格 翻页
按 q 退出
按 /关键词 搜索

8.2 --help参数

大部分命令都支持 --help 参数，显示简要帮助：

ls --help

8.3 whatis命令

快速查看命令的简要说明：

whatis ls

输出：

ls (1) - list directory contents

8.4 info命令

比 man 更详细的帮助文档：

info ls

九、常用基础命令

9.1 文本编辑器：vi/vim <a id="vi"></a>

vi 是Linux自带的经典文本编辑器，vim 是其增强版本。

vim file.txt        # 打开/创建文件
vim                  # 打开vim

三种模式：

普通模式：按 Esc 进入，用于浏览和删除
插入模式：按 i 进入，用于输入文字
命令模式：按 : 进入，用于保存退出

常用操作：

操作	命令
进入插入模式	`i`
保存	`:w`
退出	`:q`
保存并退出	`:wq` 或 `ZZ`
不保存强制退出	`:q!`
删除当前行	`dd`
复制当前行	`yy`
粘贴	`p`
撤销	`u`
搜索	`/关键词`

9.2 简单编辑器：nano <a id="nano"></a>

nano 比vim更简单，底部有快捷键提示，适合新手。

nano file.txt

常用快捷键（^ 表示 Ctrl）：

快捷键	功能
`Ctrl + O`	保存
`Ctrl + X`	退出
`Ctrl + K`	剪切一行
`Ctrl + U`	粘贴
`Ctrl + W`	搜索

9.3 系统信息：uname <a id="uname"></a>

查看系统内核信息。

uname -a            # 显示所有信息
uname -r            # 显示内核版本
uname -m            # 显示系统架构（x86_64等）

9.4 日期时间：date <a id="date"></a>

查看和设置系统日期时间。

date                # 显示当前日期时间
date +%Y-%m-%d      # 格式化输出：2026-05-25
date -s "2026-05-25 12:00:00"  # 设置时间（需要root）

9.5 命令历史：history <a id="history"></a>

查看之前执行过的命令。

history             # 显示所有历史
history 20          # 显示最近20条
!42                 # 执行第42条历史命令
!!                  # 执行上一条命令

快捷键：

↑ / ↓：浏览历史命令
Ctrl + R：反向搜索历史

9.6 清屏：clear <a id="clear"></a>

清除终端屏幕上的内容。

clear               # 清屏
# 或快捷键 Ctrl + L

9.7 重启：reboot <a id="reboot"></a>

重启系统。

sudo reboot             # 立即重启
sudo reboot -h +5       # 5分钟后重启

9.8 关机：shutdown <a id="shutdown"></a>

关闭系统。

sudo shutdown now       # 立即关机
sudo shutdown -h +10    # 10分钟后关机
sudo shutdown -r now    # 立即重启（等同于reboot）
sudo shutdown -c        # 取消定时关机

9.9 命令别名：alias <a id="alias"></a>

为常用命令创建简短别名。

alias ll='ls -la'       # 设置别名
alias rm='rm -i'        # 删除前确认
alias                   # 查看所有别名
unalias ll              # 取消别名

永久生效：将alias命令写入 ~/.bashrc 文件。

十、总结

本章学习了：

什么是Linux → 开源的操作系统内核
为什么要学Linux → 服务器霸主、开发者必备
主流发行版 → 新手推荐Ubuntu
安装方式 → 虚拟机、WSL2、云服务器
目录结构 → 所有东西都在 / 下
基本命令 → pwd、ls、cd、touch、cat
常用快捷键 → Ctrl+C终止、Tab补全
帮助命令 → man、--help、whatis

下一章预告：《Linux操作大全（二）：文件与目录操作详解》，将详细讲解文件的创建、复制、移动、删除、权限等操作。

本文参考了鸟哥的Linux私房菜等经典教程，结合实际操作经验编写。如有错误，欢迎指正！

Linux操作大全（二）：文件与目录操作详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（二）：文件与目录操作详解

本文是Linux操作大全系列的第二篇，详细讲解文件和目录的各种操作，每个命令都会解释"是干什么的"、"怎么用"、"有什么注意事项"。

一、文件操作命令

1.1 创建文件：touch

功能：创建空文件，或者更新文件的修改时间。

基本语法：

touch [选项] 文件名

常用示例：

# 创建单个空文件
touch file.txt

# 创建多个空文件
touch file1.txt file2.txt file3.txt

# 创建带空格的文件名（用引号）
touch "my file.txt"

# 更新文件的修改时间（文件已存在时）
touch existing_file.txt

实际应用场景：

快速创建一个空的日志文件
批量创建测试文件
更新文件时间戳（用于脚本判断文件是否被修改）

1.2 创建目录：mkdir

功能：创建新目录（文件夹）。

基本语法：

mkdir [选项] 目录名

常用示例：

# 创建单个目录
mkdir mydir

# 创建多级目录（-p参数很重要！）
mkdir -p /home/user/projects/2026/code

# 创建多个目录
mkdir dir1 dir2 dir3

# 创建目录并设置权限
mkdir -m 755 mydir

参数说明：

-p：递归创建目录，如果父目录不存在会自动创建
-m：设置目录权限
-v：显示创建过程

注意：不加 -p 时，如果父目录不存在会报错：

mkdir /home/user/a/b/c
# 报错：mkdir: cannot create directory '/home/user/a/b/c': No such file or directory

mkdir -p /home/user/a/b/c
# 成功！会自动创建所有缺失的父目录

1.3 删除文件：rm

功能：删除文件或目录。

基本语法：

rm [选项] 文件/目录

常用示例：

# 删除单个文件
rm file.txt

# 删除多个文件
rm file1.txt file2.txt file3.txt

# 强制删除（不提示确认）
rm -f file.txt

# 删除目录（必须加 -r）
rm -r mydir

# 强制删除目录（危险！慎用！）
rm -rf mydir

# 删除前提示确认
rm -i file.txt

参数说明：

-r：递归删除，用于删除目录
-f：强制删除，不提示确认
-i：删除前提示确认

⚠️ 危险操作警告：

# 这条命令会删除整个系统！！！绝对不要执行！！！
rm -rf /

# 这条命令会删除当前目录下所有文件！！！
rm -rf *

安全建议：

删除前先用 ls 确认要删除的内容
重要文件先备份再删除
使用 -i 参数，让系统在删除前提示你确认
不要在根目录 / 下执行 rm -rf

1.4 复制文件：cp

功能：复制文件或目录。

基本语法：

cp [选项] 源文件 目标位置

常用示例：

# 复制文件
cp file.txt file_backup.txt

# 复制到另一个目录
cp file.txt /home/user/Documents/

# 复制并重命名
cp file.txt /home/user/Documents/new_name.txt

# 复制目录（必须加 -r）
cp -r mydir mydir_backup

# 保留文件属性（权限、时间等）
cp -p file.txt file_backup.txt

# 覆盖前提示确认
cp -i file.txt /existing/file.txt

# 显示复制过程
cp -v file.txt file_backup.txt

参数说明：

-r：递归复制，用于复制目录
-p：保留文件属性
-i：覆盖前提示确认
-v：显示复制过程
-a：归档复制，等同于 -dpR，保留所有属性

1.5 移动/重命名：mv

功能：移动文件/目录，或者重命名。

基本语法：

mv [选项] 源文件 目标位置

常用示例：

# 重命名文件
mv old_name.txt new_name.txt

# 移动文件到另一个目录
mv file.txt /home/user/Documents/

# 移动并重命名
mv file.txt /home/user/Documents/new_name.txt

# 移动目录
mv mydir /home/user/Documents/

# 覆盖前提示确认
mv -i file.txt /existing/file.txt

# 不覆盖已存在的文件
mv -n file.txt /existing/file.txt

参数说明：

-i：覆盖前提示确认
-n：不覆盖已存在的文件
-v：显示移动过程

1.6 查看文件内容：cat、less、more、head、tail

cat命令

功能：一次性显示整个文件内容。

cat file.txt

# 显示行号
cat -n file.txt

# 合并多个文件
cat file1.txt file2.txt > combined.txt

适用场景：查看小文件（几十行以内）。

less命令

功能：分页查看文件内容，适合查看大文件。

less large_file.log

操作方式：

空格：下一页
b：上一页
↑ / ↓：上下滚动一行
/关键词：搜索关键词
n：下一个搜索结果
N：上一个搜索结果
q：退出

more命令

功能：类似less，但功能较少。

more file.txt

操作方式：

空格：下一页
Enter：下一行
q：退出

head命令

功能：查看文件的前几行。

# 默认显示前10行
head file.txt

# 显示前20行
head -n 20 file.txt

# 显示前5行
head -5 file.txt

适用场景：快速查看文件开头，比如查看日志的前几条记录。

tail命令

功能：查看文件的最后几行，或者实时监控文件变化。

# 默认显示最后10行
tail file.txt

# 显示最后20行
tail -n 20 file.txt

# 实时监控文件变化（非常有用！）
tail -f /var/log/syslog

# 实时监控并显示行号
tail -fn 100 /var/log/syslog

适用场景：

查看日志文件的最新内容
实时监控日志输出（tail -f 是运维最常用的命令之一）

1.7 查找文件：find

功能：在目录树中查找文件。

基本语法：

find [搜索路径] [条件] [动作]

常用示例：

# 按名字查找
find /home -name "*.txt"

# 忽略大小写
find /home -iname "*.TXT"

# 按类型查找（f=文件，d=目录）
find /home -type f -name "*.log"
find /home -type d -name "logs"

# 按大小查找
find /home -size +100M        # 大于100MB
find /home -size -10M         # 小于10MB
find /home -size 0            # 空文件

# 按时间查找
find /home -mtime -7          # 7天内修改过的文件
find /home -mtime +30         # 30天前修改过的文件
find /home -mmin -60          # 60分钟内修改过的文件

# 按权限查找
find /home -perm 777          # 权限为777的文件

# 找到后执行动作
find /home -name "*.tmp" -exec rm {} \;      # 找到后删除
find /home -name "*.log" -exec ls -l {} \;   # 找到后列出详情
find /home -name "*.txt" -exec cp {} /backup/ \;  # 找到后备份

1.8 搜索文件内容：grep

功能：在文件中搜索指定的文本。

基本语法：

grep [选项] 搜索内容 文件

常用示例：

# 基本搜索
grep "error" logfile.txt

# 忽略大小写
grep -i "error" logfile.txt

# 显示行号
grep -n "error" logfile.txt

# 递归搜索目录下所有文件
grep -r "error" /var/log/

# 显示匹配行的前后几行
grep -B 3 -A 3 "error" logfile.txt   # 前3行+后3行
grep -C 5 "error" logfile.txt        # 前后各5行

# 反向匹配（显示不包含搜索内容的行）
grep -v "debug" logfile.txt

# 统计匹配行数
grep -c "error" logfile.txt

# 使用正则表达式
grep -E "error|warning" logfile.txt
grep -E "^[0-9]" file.txt            # 以数字开头的行

参数说明：

-i：忽略大小写
-n：显示行号
-r：递归搜索
-v：反向匹配
-c：统计行数
-E：使用扩展正则表达式
-l：只显示包含匹配内容的文件名

二、目录操作命令

2.1 切换目录：cd

功能：Change Directory，切换当前工作目录。

常用示例：

# 切换到指定目录
cd /home/user/Documents

# 切换到家目录
cd ~
cd

# 切换到上一级目录
cd ..

# 切换到上上一级目录
cd ../..

# 切换到上一次所在的目录（很实用！）
cd -

# 使用绝对路径
cd /var/log

# 使用相对路径
cd Documents
cd ./subdir

2.2 显示当前目录：pwd

功能：Print Working Directory，显示当前工作目录的完整路径。

pwd

输出示例：

/home/ubuntu/Documents

2.3 列出目录内容：ls

功能：list，列出目录中的文件和子目录。

常用示例：

# 基本列表
ls

# 显示详细信息
ls -l

# 显示隐藏文件（以.开头的文件）
ls -a

# 显示详细信息+隐藏文件
ls -la

# 显示文件大小（人类可读格式）
ls -lh

# 按时间排序（最新的在前）
ls -lt

# 按大小排序（最大的在前）
ls -lS

# 递归显示子目录
ls -R

# 只显示目录
ls -d */

# 显示文件的inode号
ls -i

ls -l 输出详解：

-rw-r--r-- 1 ubuntu ubuntu 4096 May 25 10:30 file.txt

各列含义：

-rw-r--r--：文件权限（后面会详细讲）
1：硬链接数
ubuntu：所有者
ubuntu：所属组
4096：文件大小（字节）
May 25 10:30：最后修改时间
file.txt：文件名

2.4 树状显示目录：tree

功能：以树状图显示目录结构。

# 安装tree命令（如果没有）
sudo apt install tree

# 显示目录树
tree

# 只显示2层
tree -L 2

# 显示隐藏文件
tree -a

# 只显示目录
tree -d

输出示例：

.
├── Documents
│   ├── file1.txt
│   └── file2.txt
├── Downloads
│   └── image.jpg
└── Pictures
    └── photo.png

三、文件权限详解

3.1 权限的基本概念

Linux中的每个文件都有三组权限：

所有者（Owner）：文件的拥有者
所属组（Group）：文件所属的用户组
其他人（Others）：除了所有者和组成员以外的人

每组权限包含三种：

读（r）：Read，值为4
写（w）：Write，值为2
执行（x）：eXecute，值为1

3.2 权限表示方法

字符表示法

-rwxr-xr--

第1位：文件类型（- 普通文件，d 目录，l 链接）
第2-4位：所有者权限（rwx = 可读可写可执行）
第5-7位：所属组权限（r-x = 可读可执行，不可写）
第8-10位：其他人权限（r-- = 只读）

数字表示法

rwxr-xr-- = 754

计算方法：

r = 4
w = 2
x = 1
rwx = 4+2+1 = 7
r-x = 4+0+1 = 5
r-- = 4+0+0 = 4

常见权限组合：

数字	字符	含义
777	rwxrwxrwx	所有人可读可写可执行（不安全！）
755	rwxr-xr-x	所有者可读写执行，其他人可读执行
644	rw-r--r--	所有者可读写，其他人只读
700	rwx------	只有所有者可读写执行
600	rw-------	只有所有者可读写

3.3 修改权限：chmod

功能：Change Mode，修改文件权限。

常用示例：

# 数字方式设置权限
chmod 755 file.sh       # rwxr-xr-x
chmod 644 file.txt      # rw-r--r--
chmod 700 private_dir   # rwx------

# 符号方式设置权限
chmod u+x file.sh       # 给所有者添加执行权限
chmod g+w file.txt      # 给所属组添加写权限
chmod o-r file.txt      # 去掉其他人的读权限
chmod a+r file.txt      # 给所有人添加读权限

# 递归修改目录权限
chmod -R 755 /home/user/public

# 参考其他文件的权限
chmod --reference=file1.txt file2.txt

符号说明：

u：所有者（user）
g：所属组（group）
o：其他人（others）
a：所有人（all）
+：添加权限
-：去掉权限
=：设置权限

3.4 修改所有者：chown

功能：Change Owner，修改文件的所有者和所属组。

常用示例：

# 修改所有者
chown user1 file.txt

# 修改所有者和所属组
chown user1:group1 file.txt

# 只修改所属组
chown :group1 file.txt

# 递归修改目录
chown -R user1:group1 /home/user1

3.5 修改所属组：chgrp

功能：Change Group，修改文件的所属组。

# 修改所属组
chgrp group1 file.txt

# 递归修改
chgrp -R group1 /home/group1_files

四、文件压缩与解压

4.1 tar命令

功能：打包和解包文件（tar本身不压缩，只打包）。

常用示例：

# 打包目录
tar -cvf archive.tar /home/user/Documents

# 打包并gzip压缩
tar -czvf archive.tar.gz /home/user/Documents

# 打包并bzip2压缩
tar -cjvf archive.tar.bz2 /home/user/Documents

# 解包
tar -xvf archive.tar

# 解压tar.gz
tar -xzvf archive.tar.gz

# 解压tar.bz2
tar -xjvf archive.tar.bz2

# 解压到指定目录
tar -xzvf archive.tar.gz -C /home/user/backup/

# 查看压缩包内容（不解压）
tar -tzvf archive.tar.gz

参数说明：

-c：创建（create）
-x：解压（extract）
-v：显示过程（verbose）
-f：指定文件名（file）
-z：使用gzip压缩
-j：使用bzip2压缩
-C：指定解压目录

记忆口诀：

压缩：tar -czvf（c=create创建，z=zip压缩，v=verbose显示，f=file文件）
解压：tar -xzvf（x=extract解压）

4.2 gzip / gunzip

功能：压缩/解压单个文件。

# 压缩文件（会删除原文件）
gzip file.txt

# 解压文件
gunzip file.txt.gz

# 保留原文件压缩
gzip -k file.txt

# 查看压缩信息
gzip -l file.txt.gz

4.3 zip / unzip

功能：创建和解压ZIP格式的压缩包（兼容Windows）。

# 压缩文件
zip archive.zip file1.txt file2.txt

# 压缩目录（-r递归）
zip -r archive.zip /home/user/Documents

# 解压
unzip archive.zip

# 解压到指定目录
unzip archive.zip -d /home/user/extract/

# 查看压缩包内容
unzip -l archive.zip

4.4 bzip2 / bunzip2

功能：比gzip压缩率更高，但速度更慢。

# 压缩
bzip2 file.txt

# 解压
bunzip2 file.txt.bz2

4.5 xz / unxz

功能：压缩率最高，但速度最慢。

# 压缩
xz file.txt

# 解压
unxz file.txt.xz

五、链接文件

5.1 什么是链接？

链接类似于Windows的"快捷方式"，但功能更强大。

Linux有两种链接：

硬链接（Hard Link）：直接指向文件数据
软链接（Symbolic Link）：指向文件的路径

5.2 创建软链接：ln -s

# 创建软链接
ln -s /home/user/file.txt /home/user/Desktop/file_link.txt

# 创建目录的软链接
ln -s /var/www/html /home/user/website

软链接特点：

删除原文件后，软链接失效
可以链接目录
可以跨文件系统

5.3 创建硬链接：ln

# 创建硬链接
ln /home/user/file.txt /home/user/file_hardlink.txt

硬链接特点：

删除原文件后，硬链接仍然有效
不能链接目录
不能跨文件系统
硬链接和原文件共享同一个inode

六、文件搜索高级技巧

6.1 locate命令

功能：基于数据库的快速文件搜索。

# 安装mlocate
sudo apt install mlocate

# 更新数据库
sudo updatedb

# 搜索文件
locate file.txt

# 忽略大小写
locate -i FILE.TXT

# 限制结果数量
locate -n 10 "*.log"

注意：locate基于数据库搜索，新建的文件可能搜不到，需要先运行 sudo updatedb 更新数据库。

6.2 which命令

功能：查找命令的完整路径。

which ls
# 输出：/usr/bin/ls

which python3
# 输出：/usr/bin/python3

6.3 whereis命令

功能：查找命令的二进制文件、源代码和帮助文档。

whereis ls
# 输出：ls: /usr/bin/ls /usr/share/man/man1/ls.1.gz

七、文件比较

7.1 diff命令

功能：比较两个文件的差异。

# 比较两个文件
diff file1.txt file2.txt

# 并排显示差异
diff -y file1.txt file2.txt

# 显示上下文格式
diff -u file1.txt file2.txt

7.2 comm命令

功能：比较两个已排序文件的相同和不同行。

# 比较两个已排序的文件
comm sorted1.txt sorted2.txt

# 只显示相同行
comm -12 sorted1.txt sorted2.txt

八、其他常用命令

8.1 识别文件类型：file

功能：检测文件的类型（文本、图片、可执行文件等）。

# 查看文件类型
file image.jpg
# 输出：image.jpg: JPEG image data, JFIF standard 1.01

file document.pdf
# 输出：document.pdf: PDF document, version 1.7

file script.sh
# 输出：script.sh: Bourne-Again shell script, ASCII text executable

# 查看多个文件
file *

实用场景：下载的文件没有扩展名时，用 file 命令识别真实类型。

8.2 流编辑器：sed

功能：对文本进行替换、删除、插入等操作，常用于批量处理。

# 替换文件中的字符串（显示到屏幕，不修改原文件）
sed 's/old/new/' file.txt

# 全局替换（每行所有匹配）
sed 's/old/new/g' file.txt

# 直接修改原文件（加 -i 参数）
sed -i 's/old/new/g' file.txt

# 删除包含特定字符串的行
sed '/keyword/d' file.txt

# 删除空行
sed '/^$/d' file.txt

# 在第3行前插入新内容
sed '3i\新插入的内容' file.txt

# 打印第2-4行
sed -n '2,4p' file.txt

实用场景：

批量修改配置文件
日志文件处理
文本格式转换

8.3 文本处理：awk

功能：强大的文本分析工具，按列处理数据。

# 打印第一列和第三列
awk '{print $1, $3}' file.txt

# 指定分隔符（默认是空格）
awk -F: '{print $1, $3}' /etc/passwd

# 条件筛选（第三列大于100的行）
awk '$3 > 100' file.txt

# 计算总和
awk '{sum += $1} END {print sum}' numbers.txt

# 打印行号和内容
awk '{print NR, $0}' file.txt

# 格式化输出
awk '{printf "%-20s %10s
", $1, $2}' file.txt

实用场景：

处理CSV/日志文件
系统信息提取
数据统计分析

8.4 排序：sort

功能：对文本文件的行进行排序。

# 基本排序（字典序）
sort file.txt

# 数值排序
sort -n numbers.txt

# 逆序排序
sort -r file.txt

# 去重排序
sort -u file.txt

# 按第二列排序
sort -k2 file.txt

# 按第二列数值排序
sort -k2 -n file.txt

# 检查文件是否已排序
sort -c file.txt

实用场景：

整理列表数据
配合 uniq 命令去重
日志按时间排序

8.5 去重：uniq

功能：去除相邻的重复行（通常配合sort使用）。

# 去除相邻重复行
uniq file.txt

# 统计每行出现次数
uniq -c file.txt

# 只显示重复的行
uniq -d file.txt

# 只显示不重复的行
uniq -u file.txt

# 忽略大小写
uniq -i file.txt

典型用法（先排序再去重）：

sort file.txt | uniq          # 去重
sort file.txt | uniq -c       # 去重并计数
sort file.txt | uniq -c | sort -rn  # 按频率排序

8.6 统计：wc

功能：统计文件的行数、单词数、字节数。

wc file.txt         # 显示行数、单词数、字节数
wc -l file.txt      # 只显示行数
wc -w file.txt      # 只显示单词数
wc -c file.txt      # 只显示字节数
wc -m file.txt      # 只显示字符数

实用场景：

# 统计代码行数
find . -name "*.py" | xargs wc -l

# 统计目录下文件数量
ls | wc -l

# 统计日志错误次数
grep -c "ERROR" app.log

九、总结

本章详细讲解了Linux文件和目录的各种操作：

创建：touch（文件）、mkdir（目录）
删除：rm（危险操作，谨慎使用！）
复制：cp
移动/重命名：mv
查看内容：cat、less、more、head、tail
查找文件：find、locate、which、whereis
搜索内容：grep
权限管理：chmod、chown、chgrp
压缩解压：tar、gzip、zip、bzip2、xz
链接：ln（硬链接）、ln -s（软链接）

下一章预告：《Linux操作大全（三）：用户与权限管理详解》

如有疑问或发现错误，欢迎在评论区指出！

Linux操作大全（三）：用户与权限管理详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（三）：用户与权限管理详解

本文是Linux操作大全系列的第三篇，深入讲解用户管理、组管理、sudo权限等内容。

一、用户基础概念

1.1 为什么需要多用户？

Linux是一个多用户操作系统，允许多个用户同时登录和使用系统。每个用户有：

独立的家目录（/home/用户名）
独立的配置文件
独立的权限设置

1.2 用户类型

用户类型	UID范围	说明
root用户	0	超级管理员，拥有最高权限
系统用户	1-999	运行系统服务的用户，不能登录
普通用户	1000+	真实使用系统的用户

1.3 用户相关文件

/etc/passwd（用户信息文件）

每行代表一个用户，格式：

用户名:密码占位:UID:GID:备注:家目录:登录Shell

示例：

root:x:0:0:root:/root:/bin/bash
ubuntu:x:1000:1000:Ubuntu:/home/ubuntu:/bin/bash

各字段说明：

root：用户名
x：密码占位（实际密码在/etc/shadow）
0：UID（用户ID）
0：GID（主组ID）
root：备注信息
/root：家目录
/bin/bash：登录后使用的Shell

/etc/shadow（密码文件）

存储加密后的密码，只有root能查看：

root:$6$xxxxx:19000:0:99999:7:::

/etc/group（组信息文件）

每行代表一个组：

组名:密码占位:GID:组成员列表

示例：

root:x:0:
ubuntu:x:1000:
docker:x:999:ubuntu

二、用户管理命令

2.1 添加用户：useradd

功能：创建新用户。

# 基本创建（需要手动设置密码）
sudo useradd newuser

# 创建并设置家目录
sudo useradd -m newuser

# 创建并指定Shell
sudo useradd -m -s /bin/bash newuser

# 创建并添加到组
sudo useradd -m -g users -G sudo,docker newuser

# 创建并设置备注
sudo useradd -m -c "开发人员" newuser

# 创建并设置UID
sudo useradd -m -u 1500 newuser

参数说明：

-m：创建家目录
-s：指定登录Shell
-g：指定主组
-G：指定附加组
-c：设置备注
-u：指定UID

2.2 删除用户：userdel

功能：删除用户。

# 删除用户（保留家目录）
sudo userdel newuser

# 删除用户及家目录
sudo userdel -r newuser

# 强制删除（即使用户正在登录）
sudo userdel -f newuser

2.3 修改用户：usermod

功能：修改用户属性。

# 修改用户名
sudo usermod -l newname oldname

# 修改家目录
sudo usermod -d /home/newhome -m username

# 修改登录Shell
sudo usermod -s /bin/zsh username

# 添加到附加组
sudo usermod -aG docker username

# 锁定用户（禁止登录）
sudo usermod -L username

# 解锁用户
sudo usermod -U username

# 设置账号过期时间
sudo usermod -e 2026-12-31 username

# 修改备注
sudo usermod -c "新备注" username

注意：-aG 中的 -a 表示追加（append），不加 -a 会覆盖原有附加组！

2.4 设置密码：passwd

功能：设置或修改用户密码。

# 修改自己的密码
passwd

# 修改其他用户的密码（需要root权限）
sudo passwd username

# 锁定用户密码
sudo passwd -l username

# 解锁用户密码
sudo passwd -u username

# 设置密码过期时间
sudo passwd -e username

# 查看密码状态
sudo passwd -S username

密码策略建议：

长度至少8位
包含大小写字母、数字、特殊字符
不要使用常见词汇
定期更换

2.5 切换用户：su

功能：Switch User，切换到其他用户。

# 切换到root用户
su

# 切换到root（等同于上面）
su root

# 切换到指定用户
su username

# 切换用户并加载该用户的环境变量
su - username

# 切换到root并加载环境变量
su -

su vs su -：

su username：只切换用户，保留当前环境变量
su - username：切换用户并加载该用户的环境变量（推荐）

2.6 sudo命令

功能：以root权限执行命令。

# 以root权限执行命令
sudo apt update

# 以指定用户权限执行
sudo -u username command

# 编辑sudoers文件
sudo visudo

# 查看当前用户的sudo权限
sudo -l

sudoers文件配置：

编辑 /etc/sudoers（使用 visudo 命令）：

# 允许用户ubuntu执行所有命令（需要密码）
ubuntu ALL=(ALL:ALL) ALL

# 允许用户ubuntu执行所有命令（不需要密码）
ubuntu ALL=(ALL:ALL) NOPASSWD: ALL

# 允许组docker的成员执行所有命令
%docker ALL=(ALL:ALL) ALL

# 允许用户只执行特定命令
ubuntu ALL=(ALL) /usr/bin/apt, /usr/bin/systemctl

三、组管理命令

3.1 添加组：groupadd

# 创建新组
sudo groupadd developers

# 创建并指定GID
sudo groupadd -g 2000 developers

3.2 删除组：groupdel

# 删除组
sudo groupdel developers

3.3 修改组：groupmod

# 修改组名
sudo groupmod -n newname oldname

# 修改GID
sudo groupmod -g 2001 developers

3.4 管理组成员：gpasswd

# 添加用户到组
sudo gpasswd -a username groupname

# 从组中删除用户
sudo gpasswd -d username groupname

# 设置组管理员
sudo gpasswd -A username groupname

# 设置组成员列表（覆盖）
sudo gpasswd -M user1,user2,user3 groupname

3.5 查看用户所属组

# 查看当前用户的组
groups

# 查看指定用户的组
groups username

# 查看用户的详细组信息
id username

id命令输出示例：

uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),27(sudo),999(docker)

四、权限管理进阶

4.1 特殊权限

SUID（Set User ID）

当文件设置了SUID权限后，执行该文件时会以文件所有者的身份运行。

# 设置SUID
chmod u+s file.sh
chmod 4755 file.sh    # 4表示SUID

典型例子：/usr/bin/passwd 命令有SUID权限，所以普通用户也能修改自己的密码（需要写入/etc/shadow）。

SGID（Set Group ID）

当目录设置了SGID权限后，在该目录下创建的文件会继承目录的组。

# 设置SGID
chmod g+s directory
chmod 2755 directory   # 2表示SGID

典型例子：团队共享目录，所有人创建的文件都属于同一个组。

Sticky Bit

当目录设置了Sticky Bit后，只有文件所有者和root能删除该目录下的文件。

# 设置Sticky Bit
chmod +t directory
chmod 1755 directory   # 1表示Sticky Bit

典型例子：/tmp 目录设置了Sticky Bit，所有人只能删除自己创建的文件。

4.2 ACL（访问控制列表）

ACL可以为特定用户或组设置更精细的权限。

# 安装ACL工具
sudo apt install acl

# 查看文件的ACL
getfacl file.txt

# 设置ACL（给用户user1添加读写权限）
setfacl -m u:user1:rw file.txt

# 设置ACL（给组group1添加读权限）
setfacl -m g:group1:r file.txt

# 删除ACL
setfacl -x u:user1 file.txt

# 删除所有ACL
setfacl -b file.txt

# 设置默认ACL（目录下新建文件自动继承）
setfacl -d -m u:user1:rw directory/

五、用户切换与环境变量

5.1 用户切换的影响

命令	切换用户	加载环境	当前目录
`su username`	✅	❌ 保留原环境	不变
`su - username`	✅	✅ 加载新环境	切换到新用户家目录
`sudo -u username command`	临时	取决于命令	不变
`sudo -i`	✅	✅ root环境	/root
`sudo -s`	✅	❌ 保留原环境	不变

5.2 环境变量相关文件

/etc/profile（全局环境变量）

对所有用户生效，登录时加载。

~/.bashrc（用户环境变量）

只对当前用户生效，每次打开终端时加载。

~/.profile（用户登录脚本）

只对当前用户生效，登录时加载。

5.3 常用环境变量

# 查看所有环境变量
env

# 查看PATH变量
echo $PATH

# 临时设置环境变量
export MY_VAR="hello"

# 永久设置（添加到~/.bashrc）
echo 'export MY_VAR="hello"' >> ~/.bashrc
source ~/.bashrc

重要环境变量：

变量	说明
`PATH`	命令搜索路径
`HOME`	用户家目录
`USER`	当前用户名
`SHELL`	当前Shell
`LANG`	语言设置
`TERM`	终端类型

六、用户认证与安全

6.1 PAM认证

PAM（Pluggable Authentication Modules）是Linux的认证框架。

PAM配置文件位置：

/etc/pam.d/：各服务的PAM配置
/etc/pam.conf：全局PAM配置（一般不用）

PAM模块类型：

类型	说明
auth	认证（验证用户身份）
account	账户检查（是否过期、是否允许登录）
password	密码修改
session	会话管理（登录前后执行的操作）

6.2 密码策略配置

/etc/login.defs

# 密码有效期
PASS_MAX_DAYS   90      # 密码最长使用天数
PASS_MIN_DAYS   0       # 密码最短使用天数
PASS_MIN_LEN    8       # 密码最小长度
PASS_WARN_AGE   7       # 密码过期前提前警告天数

使用chage命令

# 查看密码过期信息
sudo chage -l username

# 设置密码最长使用天数
sudo chage -M 90 username

# 设置密码最短使用天数
sudo chage -m 7 username

# 设置密码过期时间
sudo chage -E 2026-12-31 username

# 强制下次登录时修改密码
sudo chage -d 0 username

6.3 登录限制

/etc/securetty

限制root只能从指定终端登录。

/etc/nologin

创建此文件后，除root外的所有用户都无法登录：

sudo touch /etc/nologin

删除此文件恢复正常登录：

sudo rm /etc/nologin

/etc/hosts.allow 和 /etc/hosts.deny

限制可以从哪些IP地址登录：

# /etc/hosts.allow
sshd: 192.168.1.0/24

# /etc/hosts.deny
sshd: ALL

七、实战场景

7.1 创建开发团队用户

# 创建开发组
sudo groupadd developers

# 创建用户并加入组
sudo useradd -m -g developers -s /bin/bash dev1
sudo useradd -m -g developers -s /bin/bash dev2
sudo useradd -m -g developers -s /bin/bash dev3

# 设置密码
sudo passwd dev1
sudo passwd dev2
sudo passwd dev3

# 创建共享目录
sudo mkdir /shared
sudo chown :developers /shared
sudo chmod 2775 /shared    # SGID + 组写权限

7.2 限制用户只能使用特定命令

# 编辑sudoers
sudo visudo

# 添加以下行
dev1 ALL=(ALL) /usr/bin/systemctl status *, /usr/bin/journalctl

7.3 批量创建用户

#!/bin/bash
# batch_create_users.sh

for i in {1..10}; do
    username="user$(printf '%03d' $i)"
    sudo useradd -m -s /bin/bash "$username"
    echo "$username:Password123" | sudo chpasswd
    sudo chage -d 0 "$username"  # 强制首次登录修改密码
    echo "Created user: $username"
done

八、总结

本章学习了：

用户类型：root、系统用户、普通用户
用户管理命令：useradd、userdel、usermod、passwd
组管理命令：groupadd、groupdel、gpasswd
sudo权限：配置sudoers文件
特殊权限：SUID、SGID、Sticky Bit
ACL：更精细的权限控制
安全策略：密码策略、登录限制

下一章预告：《Linux操作大全（四）：软件包管理详解》

如有疑问或发现错误，欢迎在评论区指出！

Linux操作大全（四）：软件包管理详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（四）：软件包管理详解

本文是Linux操作大全系列的第四篇，详细讲解如何在Linux上安装、更新、卸载软件。

一、软件包管理概述

1.1 什么是软件包？

在Linux中，软件通常以"软件包"（Package）的形式分发。一个软件包包含：

编译好的程序文件
配置文件
依赖关系说明
安装/卸载脚本

1.2 包管理器对比

包管理器	发行版	命令格式
apt	Ubuntu、Debian	`apt install 软件名`
yum	CentOS 7、RHEL 7	`yum install 软件名`
dnf	CentOS 8+、Fedora、RHEL 8+	`dnf install 软件名`
pacman	Arch Linux	`pacman -S 软件名`
zypper	openSUSE	`zypper install 软件名`
snap	跨发行版	`snap install 软件名`
flatpak	跨发行版	`flatpak install 软件名`

二、apt包管理（Ubuntu/Debian）

2.1 更新软件源

为什么要更新？ 软件源（Repository）是存放软件包的服务器。更新软件源可以获取最新的软件包列表。

# 更新软件包列表（不升级软件）
sudo apt update

# 升级所有已安装的软件
sudo apt upgrade

# 更新并升级（组合命令）
sudo apt update && sudo apt upgrade

# 发行版升级（如从22.04升到24.04）
sudo apt do-release-upgrade

2.2 搜索软件

# 搜索软件包
apt search 关键词

# 示例
apt search nginx
apt search python3

# 查看软件包详情
apt show 软件包名

# 示例
apt show nginx

2.3 安装软件

# 安装软件
sudo apt install 软件包名

# 示例
sudo apt install nginx
sudo apt install vim
sudo apt install git

# 安装多个软件
sudo apt install nginx vim git curl

# 安装指定版本
sudo apt install nginx=1.18.0-0ubuntu1

# 只下载不安装
sudo apt download 软件包名

# 重新安装
sudo apt reinstall 软件包名

2.4 卸载软件

# 卸载软件（保留配置文件）
sudo apt remove 软件包名

# 卸载软件并删除配置文件
sudo apt purge 软件包名

# 卸载并清理依赖
sudo apt autoremove

# 组合命令（卸载+清理+删配置）
sudo apt purge --auto-remove 软件包名

2.5 清理缓存

# 清理已下载的软件包缓存
sudo apt clean

# 清理过时的软件包缓存
sudo apt autoclean

# 查看缓存大小
du -sh /var/cache/apt/archives/

2.6 锁定软件版本

防止软件被意外升级：

# 锁定软件版本
sudo apt-mark hold 软件包名

# 解锁
sudo apt-mark unhold 软件包名

# 查看锁定的软件
apt-mark showhold

2.7 添加第三方PPA

PPA（Personal Package Archive）是Ubuntu的第三方软件源。

# 添加PPA
sudo add-apt-repository ppa:作者名/仓库名

# 示例：添加Python 3.11的PPA
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install python3.11

# 删除PPA
sudo add-apt-repository --remove ppa:作者名/仓库名

2.8 sources.list文件

软件源配置文件位于 /etc/apt/sources.list。

# 查看当前源
cat /etc/apt/sources.list

# 备份源文件
sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak

换源为国内镜像（提高下载速度）：

# 编辑源文件
sudo vim /etc/apt/sources.list

替换为阿里云源（Ubuntu 24.04）：

deb http://mirrors.aliyun.com/ubuntu/ noble main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ noble-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ noble-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ noble-backports main restricted universe multiverse

然后更新：

sudo apt update

三、yum/dnf包管理（CentOS/Fedora）

3.1 yum命令（CentOS 7）

# 更新软件包列表
yum check-update

# 更新所有软件
sudo yum update

# 搜索软件
yum search 关键词

# 查看软件详情
yum info 软件包名

# 安装软件
sudo yum install 软件包名

# 卸载软件
sudo yum remove 软件包名

# 清理缓存
sudo yum clean all

# 查看已安装的软件
yum list installed

# 查看可用的软件
yum list available

3.2 dnf命令（CentOS 8+/Fedora）

dnf是yum的下一代版本，用法基本相同：

# 更新软件包列表
dnf check-update

# 更新所有软件
sudo dnf update

# 搜索软件
dnf search 关键词

# 安装软件
sudo dnf install 软件包名

# 卸载软件
sudo dnf remove 软件包名

# 清理缓存
sudo dnf clean all

3.3 添加第三方仓库

# 安装EPEL仓库（Extra Packages for Enterprise Linux）
sudo yum install epel-release    # CentOS 7
sudo dnf install epel-release    # CentOS 8+

# 安装Remi仓库（PHP最新版）
sudo yum install https://rpms.remirepo.net/enterprise/remi-release-7.rpm

3.4 yum/dnf配置文件

# 主配置文件
cat /etc/yum.conf     # CentOS 7
cat /etc/dnf/dnf.conf  # CentOS 8+

# 仓库配置目录
ls /etc/yum.repos.d/   # CentOS 7
ls /etc/yum.repos.d/   # CentOS 8+

四、snap包管理

4.1 什么是snap？

snap是Canonical（Ubuntu母公司）开发的通用软件包格式，特点是：

自带依赖，不依赖系统库
自动更新
沙箱隔离，更安全
跨发行版使用

4.2 snap命令

# 安装snapd（如果没有）
sudo apt install snapd

# 搜索软件
snap search 关键词

# 安装软件
sudo snap install 软件包名

# 示例
sudo snap install code --classic    # VS Code
sudo snap install firefox
sudo snap install spotify

# 查看已安装的snap
snap list

# 更新软件
sudo snap refresh 软件包名

# 更新所有
sudo snap refresh

# 卸载软件
sudo snap remove 软件包名

4.3 snap常用软件

# 开发工具
sudo snap install code --classic        # VS Code
sudo snap install intellij-idea-community --classic  # IntelliJ IDEA
sudo snap install pycharm-community --classic        # PyCharm

# 浏览器
sudo snap install firefox
sudo snap install chromium

# 通讯
sudo snap install telegram-desktop
sudo snap install discord

# 多媒体
sudo snap install vlc
sudo snap install spotify

五、flatpak包管理

5.1 什么是flatpak？

flatpak是另一种通用软件包格式，由Red Hat主导开发。

# 安装flatpak
sudo apt install flatpak

# 添加Flathub仓库
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# 搜索软件
flatpak search 关键词

# 安装软件
flatpak install flathub 软件包名

# 查看已安装
flatpak list

# 更新软件
flatpak update

# 卸载软件
flatpak uninstall 软件包名

六、源码编译安装

6.1 什么时候需要源码编译？

软件没有提供软件包
需要自定义编译选项
需要最新版本
学习软件内部原理

6.2 编译安装步骤

步骤1：安装编译工具

# Ubuntu/Debian
sudo apt install build-essential

# CentOS/RHEL
sudo yum groupinstall "Development Tools"

步骤2：下载源码

# 使用wget下载
wget https://example.com/software-1.0.tar.gz

# 使用curl下载
curl -O https://example.com/software-1.0.tar.gz

# 使用git克隆
git clone https://github.com/example/software.git

步骤3：解压源码

tar -xzvf software-1.0.tar.gz
cd software-1.0

步骤4：配置

# 检查编译环境
./configure

# 指定安装路径
./configure --prefix=/usr/local/software

# 指定编译选项
./configure --prefix=/usr/local --enable-feature --disable-other

步骤5：编译

# 使用所有CPU核心编译
make -j$(nproc)

# 或指定核心数
make -j4

步骤6：安装

sudo make install

步骤7：清理

# 清理编译文件
make clean

# 清理配置文件
make distclean

6.3 实战：编译安装Nginx

# 安装依赖
sudo apt install build-essential libpcre3 libpcre3-dev zlib1g zlib1g-dev libssl-dev

# 下载Nginx源码
wget http://nginx.org/download/nginx-1.24.0.tar.gz

# 解压
tar -xzvf nginx-1.24.0.tar.gz
cd nginx-1.24.0

# 配置
./configure --prefix=/usr/local/nginx \
            --with-http_ssl_module \
            --with-http_v2_module \
            --with-http_realip_module

# 编译
make -j$(nproc)

# 安装
sudo make install

# 启动Nginx
sudo /usr/local/nginx/sbin/nginx

# 验证
curl http://localhost

6.4 使用checkinstall打包

checkinstall可以把源码编译的结果打包成.deb或.rpm软件包，方便管理：

# 安装checkinstall
sudo apt install checkinstall

# 编译完成后，用checkinstall代替make install
sudo checkinstall

七、软件包依赖管理

7.1 什么是依赖？

软件A可能需要软件B才能运行，软件B就是软件A的"依赖"。

7.2 自动解决依赖

现代包管理器会自动解决依赖：

# apt会自动安装依赖
sudo apt install nginx

# 查看软件的依赖
apt depends 软件包名

# 查看谁依赖这个软件
apt rdepends 软件包名

7.3 修复依赖问题

# 修复损坏的依赖
sudo apt --fix-broken install

# 强制配置
sudo dpkg --configure -a

# 清理并重新安装
sudo apt clean
sudo apt update
sudo apt install --reinstall 软件包名

八、dpkg直接操作（底层命令）

8.1 dpkg命令

dpkg是apt的底层工具，直接操作.deb软件包：

# 安装.deb包
sudo dpkg -i package.deb

# 卸载软件
sudo dpkg -r 软件包名

# 卸载并删除配置
sudo dpkg -P 软件包名

# 查看已安装的软件
dpkg -l

# 查看软件安装的文件
dpkg -L 软件包名

# 查看文件属于哪个软件
dpkg -S /usr/bin/ls

# 修复依赖
sudo apt --fix-broken install

九、实战：常用软件安装

9.1 安装Docker

# Ubuntu
sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

# 将当前用户加入docker组
sudo usermod -aG docker $USER

9.2 安装Node.js

# 使用NodeSource仓库
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install nodejs

# 验证
node --version
npm --version

9.3 安装Python 3.11

# 添加PPA
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update

# 安装
sudo apt install python3.11 python3.11-venv python3.11-dev

# 验证
python3.11 --version

9.4 安装Git

# Ubuntu/Debian
sudo apt install git

# CentOS/RHEL
sudo yum install git

# 配置Git
git config --global user.name "你的名字"
git config --global user.email "你的邮箱"

十、其他包管理工具

10.1 RPM包管理（底层）

rpm 是Red Hat系（CentOS/Fedora）的底层包管理工具。

# 安装软件包
sudo rpm -i package.rpm

# 升级软件包
sudo rpm -U package.rpm

# 卸载软件包
sudo rpm -e package_name

# 查询已安装的包
rpm -qa

# 查询某个文件属于哪个包
rpm -qf /usr/bin/ls

# 查询包的详细信息
rpm -qi package_name

# 查询包安装的文件
rpm -ql package_name

注意：rpm不会自动解决依赖，推荐使用yum/dnf代替。

10.2 Python包管理：pip

pip 是Python的包管理工具，用于安装Python库。

# 安装包
pip install requests
pip3 install requests        # 指定Python3

# 安装指定版本
pip install requests==2.28.0

# 卸载包
pip uninstall requests

# 列出已安装的包
pip list

# 查看包信息
pip show requests

# 导出依赖
pip freeze > requirements.txt

# 从文件安装依赖
pip install -r requirements.txt

# 使用国内镜像加速
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple requests

10.3 Node.js包管理：npm

npm 是Node.js的包管理工具，用于安装JavaScript库。

# 安装包（局部）
npm install express

# 安装包（全局）
npm install -g nodemon

# 安装指定版本
npm install express@4.18.0

# 卸载包
npm uninstall express

# 列出已安装的包
npm list
npm list -g                 # 全局包

# 初始化项目
npm init
npm init -y                 # 使用默认配置

# 运行脚本
npm run build
npm start

# 使用国内镜像
npm config set registry https://registry.npmmirror.com

十一、总结

本章学习了：

apt管理：update、install、remove、search
yum/dnf管理：CentOS/Fedora的包管理
snap管理：通用软件包格式
源码编译：configure、make、make install
依赖管理：自动解决、手动修复
常用软件安装：Docker、Node.js、Python、Git

下一章预告：《Linux操作大全（五）：网络配置与管理详解》

如有疑问或发现错误，欢迎在评论区指出！

Linux操作大全（五）：网络配置与管理详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（五）：网络配置与管理详解

本文是Linux操作大全系列的第五篇，详细讲解Linux网络配置和管理。

一、网络基础概念

1.1 IP地址

IP地址是网络中设备的唯一标识，类似于门牌号。

IPv4格式：192.168.1.100

IP地址分类：

类型	范围	说明
A类	1.0.0.0 - 126.255.255.255	大型网络
B类	128.0.0.0 - 191.255.255.255	中型网络
C类	192.0.0.0 - 223.255.255.255	小型网络
私有地址	10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16	局域网使用

1.2 子网掩码

子网掩码用于划分网络地址和主机地址。

常见子网掩码：

掩码	CIDR	可用主机数
255.255.255.0	/24	254
255.255.0.0	/16	65534
255.0.0.0	/8	16777214

1.3 网关

网关是连接不同网络的"关口"，通常是路由器的IP地址。

1.4 DNS

DNS（Domain Name System）将域名解析为IP地址。

常见DNS服务器：

DNS	IP地址
阿里DNS	223.5.5.5, 223.6.6.6
腾讯DNS	119.29.29.29
Google DNS	8.8.8.8, 8.8.4.4
Cloudflare DNS	1.1.1.1

二、查看网络信息

2.1 ip命令（推荐）

# 查看所有网络接口
ip addr show
ip a

# 查看指定接口
ip addr show eth0

# 查看IP地址（简略）
ip -4 addr show
ip -6 addr show

# 查看路由表
ip route show
ip r

# 查看邻居表（ARP）
ip neigh show

2.2 ifconfig命令（旧版）

# 安装net-tools（如果没有）
<a id="apt"></a>
sudo apt install net-tools

# 查看所有接口
ifconfig

# 查看指定接口
ifconfig eth0

# 启用接口
sudo ifconfig eth0 up

# 禁用接口
sudo ifconfig eth0 down

# 设置IP地址
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0

2.3 hostname命令

# 查看主机名
hostname

# 查看详细信息
hostnamectl

# 设置主机名
sudo hostnamectl set-hostname new-hostname

三、网络配置方法

3.1 Netplan（Ubuntu 18.04+）

Netplan是Ubuntu 18.04引入的网络配置工具。

配置文件位置：/etc/netplan/

# 查看配置文件
ls /etc/netplan/

# 编辑配置
sudo vim /etc/netplan/01-netcfg.yaml

静态IP配置示例：

network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses:
          - 223.5.5.5
          - 223.6.6.6

DHCP配置示例：

network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: yes

应用配置：

# 测试配置
sudo netplan try

# 应用配置
sudo netplan apply

3.2 /etc/network/interfaces（Debian传统）

# 编辑配置
sudo vim /etc/network/interfaces

静态IP配置：

auto eth0
iface eth0 inet static
    address 192.168.1.100
    netmask 255.255.255.0
    gateway 192.168.1.1
    dns-nameservers 223.5.5.5 223.6.6.6

DHCP配置：

auto eth0
iface eth0 inet dhcp

重启网络：

sudo systemctl restart networking

3.3 NetworkManager（桌面版）

# 查看连接
nmcli connection show

# 查看设备状态
nmcli device status

# 创建静态IP连接
sudo nmcli connection add type ethernet con-name static-eth0 ifname eth0 \
    ipv4.addresses 192.168.1.100/24 \
    ipv4.gateway 192.168.1.1 \
    ipv4.dns "223.5.5.5 223.6.6.6" \
    ipv4.method manual

# 启用连接
sudo nmcli connection up static-eth0

# 修改连接
sudo nmcli connection modify static-eth0 ipv4.addresses 192.168.1.101/24

# 删除连接
sudo nmcli connection delete static-eth0

3.4 /etc/sysconfig/network-scripts（CentOS 7）

# 编辑配置
sudo vim /etc/sysconfig/network-scripts/ifcfg-eth0

静态IP配置：

TYPE=Ethernet
BOOTPROTO=static
NAME=eth0
DEVICE=eth0
ONBOOT=yes
IPADDR=192.168.1.100
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
DNS1=223.5.5.5
DNS2=223.6.6.6

重启网络：

sudo systemctl restart network

四、DNS配置

4.1 /etc/resolv.conf

# 查看DNS配置
cat /etc/resolv.conf

# 临时修改DNS
sudo vim /etc/resolv.conf

添加内容：

nameserver 223.5.5.5
nameserver 223.6.6.6

注意：此文件可能会被DHCP覆盖，永久修改需要在Netplan或NetworkManager中配置。

4.2 systemd-resolved（Ubuntu 18.04+）

# 查看DNS状态
resolvectl status

# 查看DNS统计
resolvectl statistics

# 刷新DNS缓存
sudo resolvectl flush-caches

4.3 测试DNS解析

# 使用nslookup
nslookup example.com

# 使用dig
dig example.com
dig example.com A
dig example.com MX
dig @8.8.8.8 example.com

五、网络诊断工具

5.1 ping命令

功能：测试网络连通性。

# 基本ping
ping example.com

# 指定次数
ping -c 4 example.com

# 指定间隔（秒）
ping -i 0.5 example.com

# 指定包大小
ping -s 1024 example.com

# 指定TTL
ping -t 64 example.com

# 指定接口
ping -I eth0 example.com

5.2 traceroute命令

功能：追踪数据包的路由路径。

# 基本traceroute
traceroute example.com

# 使用TCP（更准确）
sudo traceroute -T example.com

# 使用UDP
traceroute -U example.com

# 指定端口
traceroute -p 80 example.com

5.3 mtr命令

功能：实时追踪路由（结合ping和traceroute）。

# 基本mtr
mtr example.com

# 报告模式
mtr -r -c 100 example.com

# 使用TCP
sudo mtr -T example.com

5.4 netstat / ss命令

功能：查看网络连接、监听端口等。

# 查看所有监听端口
sudo netstat -tuln
sudo ss -tuln

# 查看所有连接
sudo netstat -an
sudo ss -an

# 查看指定端口
sudo netstat -tuln | grep :80
sudo ss -tuln | grep :80

# 查看进程使用的端口
sudo netstat -tulnp
sudo ss -tulnp

# 查看路由表
netstat -r
ip route

5.5 curl命令

功能：发送HTTP请求。

# 基本GET请求
curl https://example.com

# 下载文件
curl -O https://example.com/file.zip

# 指定输出文件
curl -o output.html https://example.com

# POST请求
curl -X POST -d "key=value" https://example.com/api

# 携带Header
curl -H "Content-Type: application/json" https://example.com

# 显示详细信息
curl -v https://example.com

# 跟随重定向
curl -L https://example.com

# 忽略SSL证书验证
curl -k https://example.com

5.6 wget命令

功能：下载文件。

# 下载文件
wget https://example.com/file.zip

# 指定输出文件名
wget -O output.zip https://example.com/file.zip

# 后台下载
wget -b https://example.com/large-file.zip

# 断点续传
wget -c https://example.com/large-file.zip

# 递归下载（整站）
wget -r -np -k https://example.com

# 限速下载
wget --limit-rate=1m https://example.com/file.zip

5.7 nmap命令

功能：网络扫描和端口探测。

# 安装nmap
sudo apt install nmap

# 扫描指定IP的端口
nmap 192.168.1.100

# 扫描指定端口
nmap -p 80,443 192.168.1.100

# 扫描端口范围
nmap -p 1-1000 192.168.1.100

# 扫描整个网段
nmap 192.168.1.0/24

# 服务版本探测
nmap -sV 192.168.1.100

# 操作系统探测
sudo nmap -O 192.168.1.100

六、防火墙配置

6.1 ufw（Ubuntu推荐）

ufw = Uncomplicated Firewall，简单易用的防火墙。

# 启用防火墙
sudo ufw enable

# 禁用防火墙
sudo ufw disable

# 查看状态
sudo ufw status
sudo ufw status verbose
sudo ufw status numbered

# 允许端口
sudo ufw allow 22       # SSH
sudo ufw allow 80       # HTTP
sudo ufw allow 443      # HTTPS
sudo ufw allow 8080     # 自定义端口

# 允许端口范围
sudo ufw allow 3000:4000/tcp

# 允许特定IP
sudo ufw allow from 192.168.1.100

# 允许特定IP访问特定端口
sudo ufw allow from 192.168.1.100 to any port 22

# 拒绝端口
sudo ufw deny 23

# 删除规则
sudo ufw delete allow 80
sudo ufw delete 1    # 按编号删除

# 重置防火墙
sudo ufw reset

6.2 firewalld（CentOS/RHEL）

# 启动防火墙
sudo systemctl start firewalld

# 查看状态
sudo firewall-cmd --state

# 查看开放的端口
sudo firewall-cmd --list-all

# 开放端口
sudo firewall-cmd --permanent --add-port=80/tcp
sudo firewall-cmd --permanent --add-port=443/tcp

# 重载配置
sudo firewall-cmd --reload

# 关闭端口
sudo firewall-cmd --permanent --remove-port=80/tcp

# 查看服务
sudo firewall-cmd --list-services

# 开放服务
sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https

6.3 iptables（底层工具）

# 查看规则
sudo iptables -L -n
sudo iptables -L -n -v

# 允许SSH
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# 允许HTTP
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT

# 允许HTTPS
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 允许已建立的连接
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# 拒绝其他输入
sudo iptables -A INPUT -j DROP

# 删除规则
sudo iptables -D INPUT -p tcp --dport 80 -j ACCEPT

# 清空规则
sudo iptables -F

# 保存规则
sudo iptables-save > /etc/iptables.rules

# 恢复规则
sudo iptables-restore < /etc/iptables.rules

七、SSH远程连接

7.1 SSH基础

# 基本连接
ssh username@hostname

# 指定端口
ssh -p 2222 username@hostname

# 使用密钥连接
ssh -i ~/.ssh/id_rsa username@hostname

# 执行远程命令
ssh username@hostname ls -la

# 保持连接
ssh -o ServerAliveInterval=60 username@hostname

7.2 SSH密钥认证

# 生成密钥对
ssh-keygen -t ed25519 -C "your_email@example.com"

# 或使用RSA
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

# 复制公钥到服务器
ssh-copy-id username@hostname

# 或手动复制
cat ~/.ssh/id_ed25519.pub | ssh username@hostname "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

7.3 SSH配置文件

编辑 ~/.ssh/config：

Host myserver
    HostName 192.168.1.100
    User ubuntu
    Port 22
    IdentityFile ~/.ssh/id_ed25519

Host production
    HostName prod.example.com
    User deploy
    Port 2222
    IdentityFile ~/.ssh/prod_key

然后可以直接：

ssh myserver
ssh production

7.4 SCP文件传输

# 上传文件
scp file.txt username@hostname:/home/user/

# 下载文件
scp username@hostname:/home/user/file.txt ./

# 上传目录
scp -r directory/ username@hostname:/home/user/

# 指定端口
scp -P 2222 file.txt username@hostname:/home/user/

7.5 SFTP交互式传输

# 连接SFTP
sftp username@hostname

# 常用命令
sftp> ls           # 远程列表
sftp> lls          # 本地列表
sftp> pwd          # 远程当前目录
sftp> lpwd         # 本地当前目录
sftp> get file     # 下载文件
sftp> put file     # 上传文件
sftp> mkdir dir    # 创建远程目录
sftp> exit         # 退出

7.6 SSH安全加固

编辑 /etc/ssh/sshd_config：

# 禁止root登录
PermitRootLogin no

# 禁止密码登录（只允许密钥）
PasswordAuthentication no

# 修改默认端口
Port 2222

# 限制登录用户
AllowUsers ubuntu deploy

# 限制最大尝试次数
MaxAuthTries 3

# 设置超时时间
ClientAliveInterval 300
ClientAliveCountMax 2

重启SSH服务：

sudo systemctl restart sshd

八、网络服务管理

8.1 systemd管理网络服务

# 查看网络服务状态
sudo systemctl status networking
sudo systemctl status NetworkManager

# 重启网络服务
sudo systemctl restart networking

# 启用/禁用NetworkManager
sudo systemctl enable NetworkManager
sudo systemctl disable NetworkManager

8.2 网络接口管理

# 启用接口
sudo ip link set eth0 up

# 禁用接口
sudo ip link set eth0 down

# 设置MTU
sudo ip link set eth0 mtu 9000

九、实战：配置Web服务器网络

9.1 配置静态IP

# /etc/netplan/01-webserver.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses:
          - 223.5.5.5
          - 223.6.6.6

9.2 配置防火墙

# 启用防火墙
sudo ufw enable

# 允许SSH
sudo ufw allow 22/tcp

# 允许HTTP和HTTPS
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

# 查看状态
sudo ufw status

9.3 配置SSH安全

# 编辑SSH配置
sudo vim /etc/ssh/sshd_config

# 修改端口
Port 2222

# 禁止root登录
PermitRootLogin no

# 重启SSH
sudo systemctl restart sshd

# 更新防火墙规则
sudo ufw allow 2222/tcp
sudo ufw delete allow 22/tcp

十、总结

本章学习了：

网络基础：IP地址、子网掩码、网关、DNS
查看网络：ip、ifconfig、hostname
网络配置：Netplan、interfaces、NetworkManager
DNS配置：resolv.conf、systemd-resolved
网络诊断：ping、traceroute、mtr、curl、wget、nmap
防火墙：ufw、firewalld、iptables
SSH：密钥认证、安全加固、SCP/SFTP

下一章预告：《Linux操作大全（六）：进程管理与服务管理详解》

如有疑问或发现错误，欢迎在评论区指出！

Linux操作大全（六）：进程管理与服务管理详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（六）：进程管理与服务管理详解

本文是Linux操作大全系列的第六篇，详细讲解进程管理、服务管理和定时任务。

一、进程基础概念

1.1 什么是进程？

进程是正在运行的程序的实例。每个进程有：

PID：进程ID，唯一标识
PPID：父进程ID
用户：进程的所有者
状态：运行中、睡眠、停止等
资源占用：CPU、内存等

1.2 进程状态

状态	含义
R (Running)	运行中
S (Sleeping)	睡眠中（可中断）
D (Disk Sleep)	磁盘睡眠（不可中断）
T (Stopped)	已停止
Z (Zombie)	僵尸进程

1.3 前台与后台进程

前台进程：在终端中运行，占用终端
后台进程：在后台运行，不占用终端

二、查看进程

2.1 ps命令

功能：Process Status，查看进程状态。

# 查看当前终端的进程
ps

# 查看所有进程
ps aux
ps -ef

# 查看指定用户的进程
ps -u username

# 查看指定进程
ps -p 1234

# 查看进程树
ps auxf
ps -ejH

# 自定义输出格式
ps -eo pid,ppid,user,%cpu,%mem,command

ps aux输出详解：

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1 169432 11804 ?        Ss   May20   0:05 /sbin/init

各列含义：

USER：进程所有者
PID：进程ID
%CPU：CPU使用率
%MEM：内存使用率
VSZ：虚拟内存大小
RSS：实际内存大小
TTY：终端
STAT：进程状态
START：启动时间
TIME：累计CPU时间
COMMAND：命令

2.2 top命令

功能：实时监控进程状态。

# 基本使用
top

# 指定刷新间隔（秒）
top -d 1

# 指定用户
top -u username

# 指定PID
top -p 1234

top界面操作：

按键	功能
`q`	退出
`h`	帮助
`k`	杀死进程
`r`	调整优先级
`M`	按内存排序
`P`	按CPU排序
`1`	显示每个CPU核心
`c`	显示完整命令
`H`	显示线程

2.3 htop命令

功能：增强版的top，更友好。

# 安装htop
sudo apt install htop

# 使用htop
htop

# 指定用户
htop -u username

htop优势：

彩色界面
支持鼠标操作
可以直接杀死进程
树状视图

2.4 pgrep命令

功能：按名称查找进程。

# 按名称查找PID
pgrep nginx

# 显示进程名
pgrep -l nginx

# 显示完整命令
pgrep -a nginx

# 精确匹配
pgrep -x nginx

# 指定用户
pgrep -u username nginx

2.5 pidof命令

功能：查找程序的PID。

# 查找nginx的PID
pidof nginx

# 查找python的PID
pidof python3

三、进程控制

3.1 终止进程：kill

# 发送SIGTERM信号（优雅终止）
kill 1234

# 发送SIGKILL信号（强制终止）
kill -9 1234

# 发送SIGHUP信号（重新加载配置）
kill -1 1234

# 发送指定信号
kill -信号名 PID

# 查看所有信号
kill -l

常用信号：

信号	编号	作用
SIGHUP	1	重新加载配置
SIGINT	2	中断（Ctrl+C）
SIGKILL	9	强制终止
SIGTERM	15	优雅终止（默认）
SIGSTOP	19	暂停进程
SIGCONT	18	继续进程

3.2 killall命令

功能：按名称终止进程。

# 终止所有nginx进程
killall nginx

# 强制终止
killall -9 nginx

# 指定用户
killall -u username nginx

3.3 pkill命令

功能：按模式终止进程。

# 终止匹配的进程
pkill nginx

# 强制终止
pkill -9 nginx

# 指定用户
pkill -u username

# 指定终端
pkill -t pts/0

3.4 进程优先级：nice和renice

# 以低优先级启动程序
nice -n 10 command

# 以高优先级启动程序（需要root）
sudo nice -n -10 command

# 修改运行中进程的优先级
renice -n 10 -p 1234

# 修改用户所有进程的优先级
renice -n 10 -u username

优先级范围：-20（最高）到 19（默认为0）

四、后台进程管理

4.1 &符号

# 在后台运行命令
command &

# 示例
sleep 300 &

4.2 nohup命令

功能：使进程在终端关闭后继续运行。

# 基本使用
nohup command &

# 指定输出文件
nohup command > output.log 2>&1 &

# 示例
nohup python3 app.py > app.log 2>&1 &

4.3 screen命令

功能：创建可分离的终端会话。

# 安装screen
sudo apt install screen

# 创建新会话
screen -S session_name

# 分离会话（快捷键）
Ctrl+A, D

# 查看会话列表
screen -ls

# 重新连接会话
screen -r session_name

# 终止会话
screen -X -S session_name quit

4.4 tmux命令

功能：更现代的终端复用器。

# 安装tmux
sudo apt install tmux

# 创建新会话
tmux new -s session_name

# 分离会话（快捷键）
Ctrl+B, D

# 查看会话列表
tmux ls

# 重新连接会话
tmux attach -t session_name

# 终止会话
tmux kill-session -t session_name

五、systemd服务管理

5.1 什么是systemd？

systemd是Linux系统的初始化系统和服务管理器，负责：

系统启动
服务管理
日志管理
定时任务

5.2 systemctl命令

# 启动服务
sudo systemctl start nginx

# 停止服务
sudo systemctl stop nginx

# 重启服务
sudo systemctl restart nginx

# 重新加载配置
sudo systemctl reload nginx

# 查看服务状态
sudo systemctl status nginx

# 启用服务（开机自启）
sudo systemctl enable nginx

# 禁用服务
sudo systemctl disable nginx

# 查看所有服务
systemctl list-units --type=service

# 查看所有运行中的服务
systemctl list-units --type=service --state=running

# 查看服务是否启用
systemctl is-enabled nginx

# 查看服务是否活跃
systemctl is-active nginx

5.3 自定义服务文件

服务文件位于 /etc/systemd/system/ 或 /lib/systemd/system/。

创建自定义服务：

sudo vim /etc/systemd/system/myapp.service

服务文件内容：

[Unit]
Description=My Application
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/app
ExecStart=/usr/bin/python3 /home/ubuntu/app/main.py
ExecStop=/bin/kill -SIGTERM $MAINPID
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

参数说明：

[Unit]：
- Description：服务描述
- After：在什么之后启动
[Service]：
- Type：服务类型（simple、forking、oneshot等）
- User：运行用户
- WorkingDirectory：工作目录
- ExecStart：启动命令
- ExecStop：停止命令
- Restart：重启策略（always、on-failure等）
- RestartSec：重启间隔
[Install]：
- WantedBy：在什么目标下启用

启用自定义服务：

# 重新加载systemd配置
sudo systemctl daemon-reload

# 启动服务
sudo systemctl start myapp

# 启用开机自启
sudo systemctl enable myapp

# 查看状态
sudo systemctl status myapp

5.4 常见系统服务

服务名	功能
nginx	Web服务器
apache2	Web服务器
mysql	数据库
sshd	SSH服务
cron	定时任务
docker	容器服务
NetworkManager	网络管理
systemd-resolved	DNS解析
ufw	防火墙

5.5 service命令（旧版）

service 是SysVinit时代的服务管理命令，现在很多系统仍支持（实际调用systemctl）。

# 启动服务
sudo service nginx start

# 停止服务
sudo service nginx stop

# 重启服务
sudo service nginx restart

# 查看服务状态
sudo service nginx status

# 查看所有服务状态
service --status-all

提荐：新系统建议使用 systemctl 命令代替 service。

六、日志管理

6.1 journalctl命令

功能：查看systemd日志。

# 查看所有日志
journalctl

# 查看指定服务的日志
journalctl -u nginx

# 实时查看日志
journalctl -f

# 实时查看指定服务日志
journalctl -u nginx -f

# 查看今天的日志
journalctl --since today

# 查看最近1小时的日志
journalctl --since "1 hour ago"

# 查看指定时间范围
journalctl --since "2026-05-25 10:00:00" --until "2026-05-25 12:00:00"

# 查看错误日志
journalctl -p err

# 查看指定PID的日志
journalctl _PID=1234

# 清理旧日志
sudo journalctl --vacuum-time=7d
sudo journalctl --vacuum-size=500M

6.2 日志文件位置

# 系统日志
/var/log/syslog

# 认证日志
/var/log/auth.log

# 内核日志
/var/log/kern.log

# 应用日志
/var/log/nginx/
/var/log/mysql/

# 软件安装日志
/var/log/dpkg.log
/var/log/apt/

6.3 logrotate日志轮转

功能：自动轮转、压缩、删除旧日志。

配置文件：/etc/logrotate.conf 和 /etc/logrotate.d/

示例配置：

/var/log/nginx/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 www-data adm
    sharedscripts
    postrotate
        [ -f /var/run/nginx.pid ] && kill -USR1 `cat /var/run/nginx.pid`
    endscript
}

手动测试：

# 测试轮转
sudo logrotate -d /etc/logrotate.conf

# 强制轮转
sudo logrotate -f /etc/logrotate.d/nginx

七、定时任务

7.1 cron定时任务

功能：按时间计划执行命令。

# 编辑当前用户的cron
<a id="crontab"></a>
crontab -e

# 查看当前用户的cron
crontab -l

# 编辑指定用户的cron
sudo crontab -u username -e

# 删除所有cron
crontab -r

cron格式：

分 时 日 月 周 命令

时间字段说明：

字段	范围	说明
分	0-59	分钟
时	0-23	小时（24小时制）
日	1-31	日期
月	1-12	月份
周	0-7	星期（0和7都是周日）

特殊字符：

字符	含义
`*`	任意值
`,`	列表（1,3,5）
`-`	范围（1-5）
`/`	步长（*/5）

常用示例：

# 每分钟执行
* * * * * /path/to/command

# 每小时执行
0 * * * * /path/to/command

# 每天凌晨3点执行
0 3 * * * /path/to/command

# 每周一执行
0 0 * * 1 /path/to/command

# 每月1号执行
0 0 1 * * /path/to/command

# 每5分钟执行
*/5 * * * * /path/to/command

# 工作日执行
0 9 * * 1-5 /path/to/command

# 多个时间点
0 8,12,18 * * * /path/to/command

7.2 systemd定时器

功能：systemd版本的定时任务。

创建定时器：

# 创建服务文件
sudo vim /etc/systemd/system/backup.service

[Unit]
Description=Backup Service

[Service]
Type=oneshot
ExecStart=/home/user/backup.sh

# 创建定时器文件
sudo vim /etc/systemd/system/backup.timer

[Unit]
Description=Run backup daily

[Timer]
OnCalendar=*-*-* 03:00:00
Persistent=true

[Install]
WantedBy=timers.target

启用定时器：

sudo systemctl daemon-reload
sudo systemctl enable backup.timer
sudo systemctl start backup.timer

# 查看定时器状态
sudo systemctl status backup.timer
systemctl list-timers

7.3 at一次性任务

功能：在指定时间执行一次命令。

# 安装at
sudo apt install at

# 5分钟后执行
echo "command" | at now + 5 minutes

# 指定时间执行
echo "command" | at 10:00 PM

# 交互式
at 10:00 PM
at> command
at> Ctrl+D

# 查看待执行任务
atq

# 删除任务
atrm 1

八、实战：部署Web应用

8.1 创建应用服务

sudo vim /etc/systemd/system/webapp.service

[Unit]
Description=Web Application
After=network.target mysql.service

[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/app
ExecStart=/usr/bin/node /var/www/app/server.js
Restart=always
RestartSec=5
Environment=NODE_ENV=production

[Install]
WantedBy=multi-user.target

8.2 启用服务

sudo systemctl daemon-reload
sudo systemctl enable webapp
sudo systemctl start webapp
sudo systemctl status webapp

8.3 配置日志轮转

sudo vim /etc/logrotate.d/webapp

/var/log/webapp/*.log {
    daily
    missingok
    rotate 30
    compress
    delaycompress
    notifempty
    create 0640 www-data adm
    postrotate
        systemctl reload webapp
    endscript
}

8.4 配置定时备份

crontab -e

添加：

# 每天凌晨3点备份数据库
0 3 * * * /home/user/backup.sh >> /var/log/backup.log 2>&1

# 每周日凌晨清理日志
0 0 * * 0 find /var/log -name "*.gz" -mtime +30 -delete

九、总结

本章学习了：

进程查看：ps、top、htop、pgrep
进程控制：kill、killall、pkill
进程优先级：nice、renice
后台进程：nohup、screen、tmux
systemd服务：systemctl管理服务
日志管理：journalctl、logrotate
定时任务：cron、systemd定时器、at

下一章预告：《Linux操作大全（七）：Shell脚本编程详解》

如有疑问或发现错误，欢迎在评论区指出！

Linux操作大全（七）：Shell脚本编程详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（七）：Shell脚本编程详解

本文是Linux操作大全系列的第七篇，详细讲解Shell脚本编程。

一、Shell基础

1.1 什么是Shell？

Shell是Linux的命令解释器，接收用户输入的命令并执行。常见的Shell：

bash：最常用，Ubuntu默认
sh：Bourne Shell，最古老的Shell
zsh：功能更强，macOS默认
fish：用户友好，自动补全

1.2 第一个Shell脚本

#!/bin/bash
# 这是注释
<a id="echo"></a>
echo "Hello, World!"

说明：

#!/bin/bash：指定解释器（必须在第一行）
#：注释
echo：输出文字

运行脚本：

# 方法1：添加执行权限
chmod +x script.sh
./script.sh

# 方法2：使用bash命令
bash script.sh
<a id="source"></a>

# 方法3：使用source命令（在当前shell执行）
source script.sh

二、变量

2.1 变量定义

# 定义变量（等号两边不能有空格！）
name="Linux"
version=24
PI=3.14159

# 使用变量
echo $name
echo ${name}

# 变量拼接
greeting="Hello, ${name}!"
echo $greeting

2.2 特殊变量

echo "脚本名: $0"
echo "第一个参数: $1"
echo "第二个参数: $2"
echo "参数个数: $#"
echo "所有参数: $@"
echo "所有参数: $*"
echo "上一个命令的退出状态: $$"
echo "后台运行的最后一个进程ID: $!"

2.3 环境变量

# 查看所有环境变量
env

<a id="export"></a>
# 设置环境变量
export MY_VAR="hello"

# 永久设置（添加到~/.bashrc）
echo 'export MY_VAR="hello"' >> ~/.bashrc
source ~/.bashrc

常用环境变量：

变量	说明
`$HOME`	用户家目录
`$USER`	当前用户名
`$PATH`	命令搜索路径
`$SHELL`	当前Shell
`$PWD`	当前目录
`$HOSTNAME`	主机名

2.4 只读变量

readonly PI=3.14159
PI=3.14  # 报错：readonly variable

2.5 删除变量

unset name
echo $name  # 输出为空

三、字符串操作

3.1 字符串定义

# 单引号（原样输出）
str1='Hello $name'

# 双引号（解析变量）
str2="Hello $name"

echo $str1  # 输出：Hello $name
echo $str2  # 输出：Hello Linux

3.2 字符串长度

str="Hello"
echo ${#str}  # 输出：5

3.3 字符串截取

str="Hello World"

# 从第1个字符开始截取5个
echo ${str:0:5}  # 输出：Hello

# 从第6个字符开始截取
echo ${str:6}    # 输出：World

3.4 字符串替换

str="Hello World World"

# 替换第一个
echo ${str/World/Linux}  # 输出：Hello Linux World

# 替换所有
echo ${str//World/Linux} # 输出：Hello Linux Linux

# 删除匹配
echo ${str/World/}       # 输出：Hello  World

四、数组

4.1 定义数组

# 方法1
arr=(apple banana cherry)

# 方法2
arr[0]=apple
arr[1]=banana
arr[2]=cherry

4.2 访问数组

# 访问单个元素
echo ${arr[0]}    # 输出：apple
echo ${arr[1]}    # 输出：banana

# 访问所有元素
echo ${arr[@]}    # 输出：apple banana cherry

# 数组长度
echo ${#arr[@]}   # 输出：3

4.3 数组操作

# 添加元素
arr+=(date elderberry)

# 删除元素
unset arr[1]

# 切片
echo ${arr[@]:1:2}  # 从索引1开始取2个

五、运算符

5.1 算术运算

a=10
b=20

# 方法1：expr（注意空格）
c=`expr $a + $b`

# 方法2：$((...))
c=$((a + b))
c=$((a - b))
c=$((a * b))
c=$((a / b))
c=$((a % b))

# 方法3：let
let c=a+b

echo $c

5.2 关系运算

a=10
b=20

if [ $a -eq $b ]; then echo "相等"; fi
if [ $a -ne $b ]; then echo "不相等"; fi
if [ $a -gt $b ]; then echo "大于"; fi
if [ $a -lt $b ]; then echo "小于"; fi
if [ $a -ge $b ]; then echo "大于等于"; fi
if [ $a -le $b ]; then echo "小于等于"; fi

5.3 字符串运算

a="hello"
b="world"

if [ $a = $b ]; then echo "相等"; fi
if [ $a != $b ]; then echo "不相等"; fi
if [ -z $a ]; then echo "为空"; fi
if [ -n $a ]; then echo "不为空"; fi

5.4 逻辑运算

a=10
b=20

if [ $a -lt 100 ] && [ $b -gt 100 ]; then echo "AND"; fi
if [ $a -lt 100 ] || [ $b -gt 100 ]; then echo "OR"; fi
if [ ! false ]; then echo "NOT"; fi

六、流程控制

6.1 if语句

# 基本if
if [ condition ]; then
    commands
fi

# if-else
if [ condition ]; then
    commands1
else
    commands2
fi

# if-elif-else
if [ condition1 ]; then
    commands1
elif [ condition2 ]; then
    commands2
else
    commands3
fi

示例：

#!/bin/bash
age=18

if [ $age -ge 18 ]; then
    echo "成年人"
else
    echo "未成年人"
fi

6.2 case语句

#!/bin/bash
fruit="apple"

case $fruit in
    "apple")
        echo "苹果"
        ;;
    "banana")
        echo "香蕉"
        ;;
    "cherry")
        echo "樱桃"
        ;;
    *)
        echo "未知水果"
        ;;
esac

6.3 for循环

# 基本for
for i in 1 2 3 4 5; do
    echo $i
done

# 范围
for i in {1..5}; do
    echo $i
done

# C风格
for ((i=0; i<5; i++)); do
    echo $i
done

# 遍历数组
arr=(apple banana cherry)
for item in ${arr[@]}; do
    echo $item
done

# 遍历文件
for file in /home/user/*.txt; do
    echo $file
done

6.4 while循环

#!/bin/bash
count=0

while [ $count -lt 5 ]; do
    echo $count
    count=$((count + 1))
done

6.5 until循环

#!/bin/bash
count=0

until [ $count -ge 5 ]; do
    echo $count
    count=$((count + 1))
done

6.6 break和continue

# break：跳出循环
for i in {1..10}; do
    if [ $i -eq 5 ]; then
        break
    fi
    echo $i
done

# continue：跳过本次循环
for i in {1..10}; do
    if [ $i -eq 5 ]; then
        continue
    fi
    echo $i
done

七、函数

7.1 函数定义

# 方法1
function greet() {
    echo "Hello, $1!"
}

# 方法2
greet() {
    echo "Hello, $1!"
}

# 调用函数
greet "Linux"

7.2 函数参数

add() {
    local result=$(($1 + $2))
    echo $result
}

sum=$(add 10 20)
echo $sum  # 输出：30

7.3 函数返回值

# 方法1：return（只能返回0-255）
is_even() {
    if [ $(($1 % 2)) -eq 0 ]; then
        return 0
    else
        return 1
    fi
}

if is_even 4; then
    echo "偶数"
fi

# 方法2：echo
get_name() {
    echo "Linux"
}

name=$(get_name)
echo $name

7.4 局部变量

my_func() {
    local local_var="I am local"
    global_var="I am global"
}

my_func
echo $local_var  # 输出为空
echo $global_var # 输出：I am global

八、输入输出

8.1 读取输入

# 基本读取
echo "请输入名字："
read name
echo "你好，$name"

# 带提示的读取
read -p "请输入名字：" name

# 读取密码（不显示）
read -s -p "请输入密码：" password

# 读取多个变量
read -p "输入姓名和年龄：" name age
echo "$name, $age岁"

# 设置超时
read -t 5 -p "5秒内输入：" input

8.2 输出重定向

# 覆盖写入文件
echo "Hello" > file.txt

# 追加写入文件
echo "World" >> file.txt

# 错误重定向
command 2> error.log

# 同时重定向标准输出和错误
command > output.log 2>&1
command &> all.log

# 丢弃输出
command > /dev/null 2>&1

8.3 管道

# 基本管道
ls -la | grep ".txt"

# 多级管道
cat file.txt | grep "error" | wc -l
<a id="sort"></a>

# 排序去重
cat file.txt | sort | uniq

九、实战脚本

9.1 自动备份脚本

#!/bin/bash
# backup.sh - 自动备份脚本

BACKUP_DIR="/backup"
DATE=$(date +%Y%m%d_%H%M%S)
SOURCE_DIR="/home/user/data"

# 创建备份目录
mkdir -p $BACKUP_DIR

# 执行备份
tar -czf $BACKUP_DIR/backup_$DATE.tar.gz $SOURCE_DIR

# 删除7天前的备份
find $BACKUP_DIR -name "backup_*.tar.gz" -mtime +7 -delete

echo "备份完成：backup_$DATE.tar.gz"

9.2 系统监控脚本

#!/bin/bash
# monitor.sh - 系统监控脚本

echo "=== 系统信息 ==="
echo "主机名：$(hostname)"
echo "系统：$(uname -a)"
echo "运行时间：$(uptime)"

echo ""
echo "=== CPU使用率 ==="
<a id="awk"></a>
top -bn1 | grep "Cpu(s)" | awk '{print $2}'

echo ""
echo "=== 内存使用 ==="
free -h

echo ""
echo "=== 磁盘使用 ==="
df -h

echo ""
echo "=== 网络连接 ==="
ss -tuln

9.3 用户管理脚本

#!/bin/bash
# user_manage.sh - 用户管理脚本

case $1 in
    "add")
        read -p "用户名：" username
        read -s -p "密码：" password
        sudo useradd -m $username
        echo "$username:$password" | sudo chpasswd
        echo "用户 $username 创建成功"
        ;;
    "delete")
        read -p "用户名：" username
        sudo userdel -r $username
        echo "用户 $username 删除成功"
        ;;
    "list")
        cat /etc/passwd | grep -v nologin | grep -v /bin/false
        ;;
    *)
        echo "用法：$0 {add|delete|list}"
        ;;
esac

9.4 服务监控脚本

#!/bin/bash
# service_check.sh - 服务监控脚本

SERVICES="nginx mysql sshd"

for service in $SERVICES; do
    if systemctl is-active --quiet $service; then
        echo "✅ $service 运行中"
    else
        echo "❌ $service 未运行"
        # 自动重启
        sudo systemctl start $service
        echo "已尝试重启 $service"
    fi
done

9.5 日志分析脚本

#!/bin/bash
# log_analysis.sh - 日志分析脚本

LOG_FILE="/var/log/nginx/access.log"

echo "=== 访问量统计 ==="
wc -l $LOG_FILE

echo ""
echo "=== 最常访问的IP ==="
awk '{print $1}' $LOG_FILE | sort | uniq -c | sort -rn | head -10

echo ""
echo "=== 最常访问的页面 ==="
awk '{print $7}' $LOG_FILE | sort | uniq -c | sort -rn | head -10

echo ""
echo "=== 404错误 ==="
grep "404" $LOG_FILE | wc -l

十、常用工具命令

10.1 参数传递：xargs

xargs 将标准输入转换为命令参数。

# 基本用法
echo "file1 file2 file3" | xargs rm

# 指定每次传递的参数个数
echo "1 2 3 4 5 6" | xargs -n 2 echo

# 处理包含空格的文件名
find . -name "*.txt" -print0 | xargs -0 rm

# 交互式确认
echo "file1 file2" | xargs -p rm

# 替换占位符
echo "file1 file2" | xargs -I {} cp {} /backup/

# 与find配合
find . -name "*.log" | xargs grep "error"

实用场景：

# 批量删除文件
find /tmp -name "*.tmp" | xargs rm -f

# 批量修改权限
find . -name "*.sh" | xargs chmod +x

# 批量压缩
find . -name "*.txt" | xargs tar -czf texts.tar.gz

10.2 输出分流：tee

tee 将输出同时显示到屏幕和写入文件。

# 基本用法：输出到屏幕和文件
echo "Hello" | tee output.txt

# 追加到文件
echo "World" | tee -a output.txt

# 配合管道使用
ls -la | tee file_list.txt | wc -l

# 记录命令输出
ping google.com | tee ping_log.txt

# 同时记录标准输出和错误输出
command 2>&1 | tee output.log

实用场景：

# 安装软件时记录日志
sudo apt install nginx | tee install.log

# 编译时记录输出
make 2>&1 | tee build.log

# 查看并保存磁盘信息
df -h | tee disk_info.txt

10.3 循环监控：watch

watch 定期执行命令并刷新显示，用于实时监控。

# 每2秒刷新（默认）
watch df -h

# 每5秒刷新
watch -n 5 free -h

# 高亮变化的部分
watch -d df -h

# 监控文件变化
watch -d -n 1 ls -la /var/log/

# 监控网络连接
watch -n 1 'ss -tuln | wc -l'

# 监控进程
watch -n 1 'ps aux | grep nginx'

实用场景：

# 监控磁盘使用
watch df -h

# 监控内存
watch -n 1 free -h

# 监控日志增长
watch -n 1 wc -l /var/log/syslog

# 监控Docker容器
watch docker ps

十一、调试技巧

10.1 调试选项

# 语法检查
bash -n script.sh

# 跟踪执行
bash -x script.sh

# 在脚本中开启调试
#!/bin/bash
set -x  # 开启调试
# ... 脚本内容
set +x  # 关闭调试

10.2 错误处理

#!/bin/bash
set -e  # 遇到错误立即退出
set -u  # 使用未定义变量报错
set -o pipefail  # 管道中任意命令失败则失败

# 或者使用trap
trap 'echo "错误发生在第 $LINENO 行"' ERR

十一、总结

本章学习了：

Shell基础：脚本定义、运行方式
变量：定义、特殊变量、环境变量
字符串：定义、长度、截取、替换
数组：定义、访问、操作
运算符：算术、关系、逻辑
流程控制：if、case、for、while
函数：定义、参数、返回值
输入输出：read、重定向、管道
实战脚本：备份、监控、日志分析

下一章预告：《Linux操作大全（八）：磁盘与存储管理详解》

如有疑问或发现错误，欢迎在评论区指出！

Linux操作大全（八）：磁盘与存储管理详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（八）：磁盘与存储管理详解

本文是Linux操作大全系列的第八篇，详细讲解磁盘管理、文件系统、RAID、LVM等知识。

一、磁盘基础概念

1.1 磁盘类型

类型	特点	适用场景
HDD（机械硬盘）	容量大、价格便宜、速度慢	存储大量数据
SSD（固态硬盘）	速度快、价格贵、寿命有限	系统盘、频繁读写
NVMe SSD	速度极快、价格最贵	高性能应用

1.2 磁盘命名规则

设备类型	命名规则	示例
SATA/SAS	/dev/sd[a-z]	/dev/sda, /dev/sdb
NVMe	/dev/nvme[0-9]n[0-9]	/dev/nvme0n1
虚拟磁盘	/dev/vd[a-z]	/dev/vda
分区	/dev/sda[1-9]	/dev/sda1, /dev/sda2

二、磁盘信息查看

2.1 lsblk命令

功能：列出块设备。

# 查看所有块设备
lsblk

# 显示文件系统类型
lsblk -f

# 显示详细信息
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT,FSTYPE

# 显示所有设备（包括空设备）
lsblk -a

输出示例：

NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda      8:0    0   100G  0 disk 
├─sda1   8:1    0    50G  0 part /
├─sda2   8:2    0    40G  0 part /home
└─sda3   8:3    0    10G  0 part [SWAP]
sdb      8:16   0   500G  0 disk 
└─sdb1   8:17   0   500G  0 part /data

2.2 fdisk命令

功能：磁盘分区工具（MBR分区表）。

# 查看磁盘分区
sudo fdisk -l

# 查看指定磁盘
sudo fdisk -l /dev/sda

# 进入分区工具
sudo fdisk /dev/sdb

fdisk交互命令：

命令	功能
`p`	打印分区表
`n`	新建分区
`d`	删除分区
`t`	更改分区类型
`l`	列出分区类型
`w`	保存并退出
`q`	不保存退出

2.3 parted命令

功能：支持GPT分区表的分区工具。

# 查看分区
sudo parted /dev/sdb print

# 进入交互模式
sudo parted /dev/sdb

# 直接创建分区
sudo parted /dev/sdb mklabel gpt
sudo parted /dev/sdb mkpart primary ext4 0% 50%
sudo parted /dev/sdb mkpart primary ext4 50% 100%

2.4 df命令

功能：显示磁盘空间使用情况。

# 查看所有文件系统
df -h

# 查看指定目录
df -h /home

# 显示文件系统类型
df -Th

# 显示inode使用情况
df -i

2.5 du命令

功能：显示目录或文件的磁盘使用情况。

# 查看当前目录
du -sh .

# 查看指定目录
du -sh /home/user

# 查看所有子目录
du -h --max-depth=1

# 按大小排序
du -h --max-depth=1 | sort -hr

# 排除某些目录
du -h --max-depth=1 --exclude='.git'

三、文件系统

3.1 常见文件系统

文件系统	特点	适用场景
ext4	Linux默认，稳定可靠	通用场景
XFS	高性能，支持大文件	大数据、数据库
Btrfs	支持快照、压缩	高级存储
NTFS	Windows兼容	双系统
FAT32	跨平台兼容	U盘、移动硬盘

3.2 创建文件系统（格式化）

# 格式化为ext4
<a id="mkfs"></a>
sudo mkfs.ext4 /dev/sdb1

# 格式化为XFS
sudo mkfs.xfs /dev/sdb1

# 格式化为NTFS
sudo mkfs.ntfs /dev/sdb1

# 格式化为FAT32
sudo mkfs.vfat -F 32 /dev/sdb1

3.3 检查文件系统

# 检查ext4
sudo fsck /dev/sdb1
sudo fsck.ext4 /dev/sdb1

# 检查XFS
sudo xfs_repair /dev/sdb1

# 自动修复
sudo fsck -y /dev/sdb1

注意：检查前必须卸载文件系统！

3.4 调整文件系统大小

# 扩展ext4
sudo resize2fs /dev/sdb1

<a id="mount"></a>
# 扩展XFS（只能在线扩展）
sudo xfs_growfs /mount/point

四、挂载与卸载

4.1 挂载命令

# 基本挂载
sudo mount /dev/sdb1 /mnt/data

# 指定文件系统类型
sudo mount -t ext4 /dev/sdb1 /mnt/data

# 只读挂载
sudo mount -o ro /dev/sdb1 /mnt/data

# 读写挂载
sudo mount -o rw /dev/sdb1 /mnt/data

# 挂载ISO文件
sudo mount -o loop image.iso /mnt/iso

# 挂载NFS
sudo mount -t nfs server:/share /mnt/nfs

4.2 卸载命令

# 卸载
sudo umount /mnt/data

# 卸载设备
sudo umount /dev/sdb1

# 强制卸载
sudo umount -l /mnt/data

# 卸载所有
sudo umount -a

4.3 开机自动挂载

编辑 /etc/fstab：

# 查看UUID
<a id="blkid"></a>
sudo blkid

# 编辑fstab
sudo vim /etc/fstab

fstab格式：

UUID=xxx  /mount/point  ext4  defaults  0  0

字段说明：

设备（UUID或路径）
挂载点
文件系统类型
挂载选项
dump备份（0=不备份）
fsck检查顺序（0=不检查，1=根分区，2=其他）

示例：

UUID=12345678-1234-1234-1234-123456789012  /data  ext4  defaults  0  2

测试fstab：

# 测试（不实际挂载）
sudo mount -a

五、交换空间（Swap）

5.1 什么是Swap？

Swap是磁盘上的一块空间，当物理内存不足时，系统会将部分内存数据交换到Swap中。

5.2 创建Swap分区

# 创建Swap分区
<a id="swapon"></a>
sudo mkswap /dev/sdb2

# 启用Swap
sudo swapon /dev/sdb2

# 查看Swap状态
swapon --show
free -h

5.3 创建Swap文件

# 创建Swap文件
sudo fallocate -l 4G /swapfile

# 设置权限
sudo chmod 600 /swapfile

# 格式化为Swap
sudo mkswap /swapfile

# 启用
sudo swapon /swapfile

5.4 Swap配置

编辑 /etc/fstab：

/swapfile  none  swap  sw  0  0

调整Swappiness（系统使用Swap的倾向）：

# 查看当前值
cat /proc/sys/vm/swappiness

# 临时修改
sudo sysctl vm.swappiness=10

# 永久修改
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf

六、RAID配置

6.1 RAID级别

级别	名称	最少磁盘	特点
RAID0	条带化	2	高性能，无冗余
RAID1	镜像	2	数据安全，容量减半
RAID5	分布式奇偶校验	3	性能和安全平衡
RAID6	双奇偶校验	4	允许2块磁盘故障
RAID10	镜像+条带	4	高性能+高安全

6.2 软RAID配置（mdadm）

# 安装mdadm
sudo apt install mdadm

# 创建RAID1
sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1

# 创建RAID5
sudo mdadm --create /dev/md0 --level=5 --raid-devices=3 /dev/sdb1 /dev/sdc1 /dev/sdd1

# 查看RAID状态
cat /proc/mdstat
sudo mdadm --detail /dev/md0

# 保存配置
sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf

七、LVM（逻辑卷管理）

7.1 什么是LVM？

LVM（Logical Volume Manager）允许灵活管理磁盘空间，可以动态扩展和缩小分区。

LVM概念：

PV（Physical Volume）：物理卷，实际的磁盘或分区
VG（Volume Group）：卷组，由多个PV组成
LV（Logical Volume）：逻辑卷，从VG中划分

7.2 创建LVM

# 1. 创建物理卷
sudo pvcreate /dev/sdb1 /dev/sdc1

# 查看物理卷
sudo pvs
sudo pvdisplay

# 2. 创建卷组
sudo vgcreate my_vg /dev/sdb1 /dev/sdc1

# 查看卷组
sudo vgs
sudo vgdisplay

# 3. 创建逻辑卷
sudo lvcreate -L 100G -n my_lv my_vg

# 或使用百分比
sudo lvcreate -l 100%FREE -n my_lv my_vg

# 查看逻辑卷
sudo lvs
sudo lvdisplay

# 4. 格式化
sudo mkfs.ext4 /dev/my_vg/my_lv

# 5. 挂载
sudo mount /dev/my_vg/my_lv /mnt/data

7.3 扩展LVM

# 1. 添加新磁盘到卷组
sudo pvcreate /dev/sdd1
sudo vgextend my_vg /dev/sdd1

# 2. 扩展逻辑卷
sudo lvextend -L +50G /dev/my_vg/my_lv

# 3. 扩展文件系统
sudo resize2fs /dev/my_vg/my_lv

# 或一步完成
sudo lvextend -L +50G --resize /dev/my_vg/my_lv

7.4 缩小LVM

# 1. 卸载
sudo umount /mnt/data

# 2. 检查文件系统
sudo fsck /dev/my_vg/my_lv

# 3. 缩小文件系统
sudo resize2fs /dev/my_vg/my_lv 50G

# 4. 缩小逻辑卷
sudo lvreduce -L 50G /dev/my_vg/my_lv

# 5. 重新挂载
sudo mount /dev/my_vg/my_lv /mnt/data

7.5 LVM快照

# 创建快照
sudo lvcreate -L 10G -s -n my_lv_snap /dev/my_vg/my_lv

# 恢复快照
sudo lvconvert --merge /dev/my_vg/my_lv_snap

八、实战：配置数据存储

8.1 配置新磁盘

# 查看新磁盘
lsblk

# 创建分区
sudo fdisk /dev/sdb
# n -> p -> 1 -> 回车 -> 回车 -> w

# 格式化
sudo mkfs.ext4 /dev/sdb1

# 创建挂载点
sudo mkdir /data

# 挂载
sudo mount /dev/sdb1 /data

# 添加到fstab
echo 'UUID=xxx  /data  ext4  defaults  0  2' | sudo tee -a /etc/fstab

8.2 配置LVM存储池

# 准备磁盘
sudo pvcreate /dev/sdb1 /dev/sdc1 /dev/sdd1

# 创建卷组
sudo vgcreate storage_vg /dev/sdb1 /dev/sdc1 /dev/sdd1

# 创建逻辑卷
sudo lvcreate -L 500G -n data_lv storage_vg

# 格式化挂载
sudo mkfs.xfs /dev/storage_vg/data_lv
sudo mount /dev/storage_vg/data_lv /data

# 配置fstab
echo '/dev/storage_vg/data_lv  /data  xfs  defaults  0  2' | sudo tee -a /etc/fstab

九、总结

本章学习了：

磁盘基础：类型、命名规则
磁盘信息：lsblk、fdisk、df、du
文件系统：ext4、XFS、创建、检查
挂载卸载：mount、umount、fstab
Swap：创建Swap分区和文件
RAID：各级别特点、配置方法
LVM：PV、VG、LV、扩展、快照

下一章预告：《Linux操作大全（九）：系统监控与性能优化详解》

如有疑问或发现错误，欢迎在评论区指出！

Linux操作大全（九）：系统监控与性能优化详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（九）：系统监控与性能优化详解

本文是Linux操作大全系列的第九篇，详细讲解系统监控工具和性能优化技巧。

一、系统监控工具

1.1 uptime命令

功能：显示系统运行时间和负载。

uptime

输出示例：

 20:36:51 up 10 days,  3:25,  2 users,  load average: 0.08, 0.03, 0.01

负载解读：

1分钟平均负载：0.08
5分钟平均负载：0.03
15分钟平均负载：0.01

负载标准：

CPU核心数	正常负载	高负载
1核	< 1.0	> 1.0
4核	< 4.0	> 4.0
8核	< 8.0	> 8.0

1.2 free命令

功能：显示内存使用情况。

# 基本查看
free -h

# 详细信息
free -hl

# 持续监控
free -h -s 2  # 每2秒刷新

输出示例：

              total        used        free      shared  buff/cache   available
Mem:           7.7G        2.1G        3.2G        256M        2.4G        5.1G
Swap:          2.0G        0.0B        2.0G

内存说明：

total：总内存
used：已使用
free：空闲内存
shared：共享内存
buff/cache：缓冲/缓存
available：可用内存（free + buff/cache）

1.3 vmstat命令

功能：虚拟内存统计。

# 基本查看
vmstat

# 每2秒刷新，共10次
vmstat 2 10

# 显示详细信息
vmstat -w

# 显示磁盘统计
vmstat -d

输出说明：

procs：进程
- r：运行队列
- b：阻塞进程
memory：内存
- swpd：虚拟内存使用
- free：空闲内存
- buff：缓冲
- cache：缓存
swap：交换
- si：从磁盘交换到内存
- so：从内存交换到磁盘
io：磁盘
- bi：读入
- bo：写出
system：系统
- in：中断
- cs：上下文切换
cpu：CPU
- us：用户空间
- sy：内核空间
- id：空闲
- wa：等待IO

1.4 iostat命令

功能：IO统计。

# 基本查看
iostat

# 每2秒刷新
iostat 2

# 显示详细信息
iostat -x

# 显示指定设备
iostat -x sda

1.5 sar命令

功能：系统活动报告。

# 安装sysstat
sudo apt install sysstat

# 启用数据收集
sudo systemctl enable sysstat
sudo systemctl start sysstat

# CPU使用率
sar -u

# 内存使用
sar -r

# 磁盘IO
sar -b

# 网络统计
sar -n DEV

# 指定时间范围
sar -u -s 10:00:00 -e 12:00:00

# 历史数据
sar -u -f /var/log/sysstat/sa25

1.6 dmesg命令

功能：显示内核环形缓冲区消息，用于查看系统启动信息、硬件检测、驱动加载、内核错误等。

# 查看所有内核消息
dmesg

# 查看最近的内核消息（最后20行）
dmesg | tail -20

# 查看最近的内核消息（最后50行）
dmesg | tail -50

# 实时监控内核消息
dmesg -w

# 查看错误和警告信息
dmesg | grep -i error
dmesg | grep -i warn

# 查看特定设备信息（如USB设备）
dmesg | grep -i usb

# 查看磁盘相关消息
dmesg | grep -i sda

# 查看内存相关消息
dmesg | grep -i memory

# 查看网络相关消息
dmesg | grep -i eth

# 查看启动时间信息
dmesg | grep -i "linux version"

# 查看硬件信息
dmesg | grep -i "detected"

# 清空内核环形缓冲区（需要root权限）
sudo dmesg -c

# 以人类可读的时间戳显示
dmesg -T

# 以纪元时间戳显示
dmesg -e

# 查看指定级别的消息（0-7）
dmesg -l err          # 只显示错误
dmesg -l warn         # 只显示警告
dmesg -l info         # 只显示信息
dmesg -l debug        # 只显示调试信息

输出格式说明：

[时间戳] 设备名: 消息内容
[    0.000000] Linux version 5.15.0-generic (buildd@lcy02-amd64-005)
[    1.234567] usb 1-1: New USB device found, idVendor=1d6b, idProduct=0002

常见使用场景：

系统故障排查：查看是否有硬件错误或驱动问题
USB设备诊断：检查USB设备是否被正确识别
磁盘问题检测：查看磁盘IO错误
网络故障排查：检查网卡是否正常加载
内存问题诊断：查看内存分配错误

注意事项：

dmesg显示的是内核消息，需要root权限才能查看完整信息
使用 -T 选项可以显示人类可读的时间戳
使用 -w 选项可以实时监控新的内核消息
内核环形缓冲区大小有限，旧消息会被新消息覆盖

二、CPU监控与优化

2.1 CPU信息查看

# 查看CPU信息
lscpu

# 查看CPU型号
cat /proc/cpuinfo | grep "model name" | head -1

# 查看CPU核心数
nproc

# 查看CPU使用率
top -bn1 | grep "Cpu(s)"

2.2 CPU监控工具

# top（实时监控）
top

# htop（增强版）
htop

# mpstat（多核CPU统计）
mpstat -P ALL 2

# pidstat（进程CPU统计）
pidstat -u 2

2.3 CPU优化技巧

1. 调整进程优先级

# 降低优先级
nice -n 10 command

# 提高优先级
sudo nice -n -10 command

2. CPU亲和性

# 绑定进程到指定CPU核心
taskset -c 0,1 command

# 修改运行中进程的CPU亲和性
taskset -pc 0,1 1234

3. 内核参数调优

# 查看调度器
cat /proc/sys/kernel/sched_min_granularity_ns

# 调整调度器参数
echo 10000000 | sudo tee /proc/sys/kernel/sched_min_granularity_ns

三、内存监控与优化

3.1 内存信息查看

# 查看内存信息
free -h

# 查看详细内存信息
cat /proc/meminfo

# 查看内存使用最多的进程
ps aux --sort=-%mem | head -10

3.2 内存监控工具

# vmstat
vmstat 2

# sar
sar -r 2

# pidstat
pidstat -r 2

3.3 内存优化技巧

1. 清理缓存

# 清理页面缓存
sudo sync; echo 1 | sudo tee /proc/sys/vm/drop_caches

# 清理目录项和inode
sudo sync; echo 2 | sudo tee /proc/sys/vm/drop_caches

# 清理所有缓存
sudo sync; echo 3 | sudo tee /proc/sys/vm/drop_caches

2. 调整Swappiness

# 查看当前Swappiness
cat /proc/sys/vm/swappiness

# 临时修改（减少Swap使用）
echo 10 | sudo tee /proc/sys/vm/swappiness

# 永久修改
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

3. 内存过量提交

# 查看当前设置
cat /proc/sys/vm/overcommit_memory

# 设置为启发式（默认）
echo 0 | sudo tee /proc/sys/vm/overcommit_memory

# 设置为总是允许
echo 1 | sudo tee /proc/sys/vm/overcommit_memory

# 设置为不允许过量
echo 2 | sudo tee /proc/sys/vm/overcommit_memory

四、磁盘监控与优化

4.1 磁盘监控工具

# iostat
iostat -x 2

# iotop（需要root）
sudo iotop

# iostat详细信息
iostat -xdm 2

4.2 磁盘优化技巧

1. 调整IO调度器

# 查看当前调度器
cat /sys/block/sda/queue/scheduler

# 修改调度器
echo "noop" | sudo tee /sys/block/sda/queue/scheduler
echo "deadline" | sudo tee /sys/block/sda/queue/scheduler
echo "cfq" | sudo tee /sys/block/sda/queue/scheduler

# SSD推荐noop或deadline
# HDD推荐cfq

2. 调整预读大小

# 查看当前预读大小
sudo blockdev --getra /dev/sda

# 修改预读大小（4096=2MB）
sudo blockdev --setra 4096 /dev/sda

3. 调整文件系统参数

# 挂载时使用noatime（不记录访问时间）
sudo mount -o remount,noatime /

# 在fstab中永久设置
UUID=xxx  /  ext4  defaults,noatime  0  1

五、网络监控与优化

5.1 网络监控工具

# iftop（需要安装）
sudo apt install iftop
sudo iftop

# nethogs（按进程显示流量）
sudo apt install nethogs
sudo nethogs

# ss（查看连接）
ss -tuln

# netstat
netstat -tuln

5.2 网络优化技巧

1. 调整TCP缓冲区

# 查看当前设置
sysctl net.ipv4.tcp_rmem
sysctl net.ipv4.tcp_wmem

# 调整缓冲区大小
echo "net.ipv4.tcp_rmem = 4096 87380 16777216" | sudo tee -a /etc/sysctl.conf
echo "net.ipv4.tcp_wmem = 4096 65536 16777216" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

2. 启用TCP窗口缩放

echo "net.ipv4.tcp_window_scaling = 1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

3. 调整连接队列

echo "net.core.somaxconn = 65535" | sudo tee -a /etc/sysctl.conf
echo "net.ipv4.tcp_max_syn_backlog = 65535" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

六、综合监控工具

6.1 nmon

# 安装
sudo apt install nmon

# 运行
nmon

nmon快捷键：

c：CPU
m：内存
d：磁盘
n：网络
t：进程
q：退出

6.2 dstat

# 安装
sudo apt install dstat

# 基本使用
dstat

# 指定监控项
dstat -cdnm

# 输出到文件
dstat -cdnm --output stats.csv

6.3 glances

# 安装
sudo apt install glances

# 运行
glances

# Web模式
glances -w

七、性能优化实战

7.1 Web服务器优化

# 调整文件描述符限制
echo "* soft nofile 65535" | sudo tee -a /etc/security/limits.conf
echo "* hard nofile 65535" | sudo tee -a /etc/security/limits.conf

# 调整内核参数
cat >> /etc/sysctl.conf << EOF
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 1200
net.ipv4.ip_local_port_range = 10000 65535
net.ipv4.tcp_max_syn_backlog = 8192
net.core.somaxconn = 32768
EOF
sudo sysctl -p

7.2 数据库优化

# 调整共享内存
echo "kernel.shmmax = 68719476736" | sudo tee -a /etc/sysctl.conf
echo "kernel.shmall = 4294967296" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# 调整文件系统
sudo mount -o remount,noatime,barrier=0 /

7.3 容器环境优化

# 调整cgroup内存限制
echo "vm.overcommit_memory = 1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# 调整网络桥接
echo "net.bridge.bridge-nf-call-iptables = 1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

八、监控脚本示例

8.1 系统监控脚本

#!/bin/bash
# system_monitor.sh

echo "===================="
echo "系统监控报告"
echo "===================="
echo ""

echo "【系统信息】"
echo "主机名: $(hostname)"
echo "系统: $(uname -r)"
echo "运行时间: $(uptime -p)"
echo ""

echo "【CPU使用率】"
top -bn1 | grep "Cpu(s)" | awk '{print "用户: "$2"%  系统: "$4"%  空闲: "$8"%"}'
echo ""

echo "【内存使用】"
free -h | awk '/Mem:/ {print "总计: "$2"  已用: "$3"  空闲: "$4"  可用: "$7}'
echo ""

echo "【磁盘使用】"
df -h | awk '$5+0 > 80 {print "⚠️  "$6" 使用率: "$5}'
echo ""

echo "【负载信息】"
echo "1分钟: $(cat /proc/loadavg | awk '{print $1}')"
echo "5分钟: $(cat /proc/loadavg | awk '{print $2}')"
echo "15分钟: $(cat /proc/loadavg | awk '{print $3}')"
echo ""

echo "【Top 5 CPU进程】"
ps aux --sort=-%cpu | head -6
echo ""

echo "【Top 5 内存进程】"
ps aux --sort=-%mem | head -6

8.2 告警脚本

#!/bin/bash
# alert.sh

# CPU使用率阈值
CPU_THRESHOLD=80

# 内存使用率阈值
MEM_THRESHOLD=90

# 磁盘使用率阈值
DISK_THRESHOLD=85

# 检查CPU
CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}')
if (( $(echo "$CPU_USAGE > $CPU_THRESHOLD" | bc -l) )); then
    echo "⚠️ CPU使用率过高: ${CPU_USAGE}%"
fi

# 检查内存
MEM_USAGE=$(free | awk '/Mem:/ {printf "%.0f", $3/$2*100}')
if [ $MEM_USAGE -gt $MEM_THRESHOLD ]; then
    echo "⚠️ 内存使用率过高: ${MEM_USAGE}%"
fi

# 检查磁盘
df -h | awk '$5+0 > '$DISK_THRESHOLD' {print "⚠️ "$6" 使用率: "$5}'

十、硬件信息查看

10.1 PCI设备：lspci

查看PCI总线设备（显卡、网卡、声卡等）。

# 列出所有PCI设备
lspci

# 显示详细信息
lspci -v

# 显示更详细信息
lspci -vv

# 显示厂商和设备ID
lspci -nn

# 过滤显示（如显卡）
lspci | grep -i vga
lspci | grep -i nvidia

实用场景：

# 查看显卡型号
lspci | grep -i vga

# 查看网卡型号
lspci | grep -i network

# 查看声卡型号
lspci | grep -i audio

10.2 USB设备：lsusb

查看USB设备信息。

# 列出所有USB设备
lsusb

# 显示详细信息
lsusb -v

# 显示厂商和设备ID
lsusb -t

实用场景：

# 查看USB设备列表
lsusb

# 查看USB存储设备
lsusb | grep -i storage

# 查看摄像头
lsusb | grep -i camera

10.3 硬件温度：sensors

查看CPU、主板等硬件温度（需安装 lm-sensors）。

# 安装sensors
sudo apt install lm-sensors

# 检测硬件传感器
sudo sensors-detect

# 查看温度
sensors

**输出示例：

coretemp-isa-0000
Adapter: ISA adapter
Core 0:       +45.0°C  (high = +80.0°C, crit = +100.0°C)
Core 1:       +43.0°C  (high = +80.0°C, crit = +100.0°C)

实用场景：

# 监控CPU温度
watch -n 1 sensors

# 检查是否过热
sensors | grep -i temp

十一、总结

本章学习了：

监控工具：uptime、free、vmstat、iostat、sar
CPU监控：lscpu、mpstat、pidstat、优化技巧
内存监控：free、vmstat、清理缓存、调整Swappiness
磁盘监控：iostat、iotop、IO调度器、预读设置
网络监控：iftop、nethogs、TCP缓冲区优化
综合工具：nmon、dstat、glances
实战优化：Web服务器、数据库、容器环境

下一章预告：《Linux操作大全（十）：Docker与容器技术详解》

如有疑问或发现错误，欢迎在评论区指出！

Linux操作大全（十）：Docker与容器技术详解

Mon, 25 May 2026 00:00:00 GMT

Linux操作大全（十）：Docker与容器技术详解

本文是Linux操作大全系列的第十篇，详细讲解Docker容器技术。

一、Docker基础概念

1.1 什么是Docker？

Docker是一个开源的容器化平台，允许开发者将应用及其依赖打包到一个轻量级、可移植的容器中。

核心概念：

镜像（Image）：只读模板，包含运行应用所需的一切
容器（Container）：镜像的运行实例
仓库（Registry）：存储镜像的地方（如Docker Hub）

1.2 容器 vs 虚拟机

特性	容器	虚拟机
启动速度	秒级	分钟级
资源占用	少	多
隔离性	进程级	系统级
镜像大小	MB级	GB级
性能	接近原生	有损耗

1.3 Docker架构

┌─────────────────────────────────────┐
│            Docker Client            │
├─────────────────────────────────────┤
│            Docker Daemon            │
├─────────┬─────────┬─────────────────┤
│ Images  │Container│   Networks      │
└─────────┴─────────┴─────────────────┘

二、Docker安装

2.1 Ubuntu安装Docker

# 更新包索引
sudo apt update

# 安装依赖
sudo apt install apt-transport-https ca-certificates curl software-properties-common

# 添加Docker官方GPG密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 添加Docker仓库
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

# 将当前用户加入docker组
sudo usermod -aG docker $USER

# 重新登录或运行
newgrp docker

2.2 CentOS安装Docker

# 安装依赖
sudo yum install -y yum-utils

# 添加Docker仓库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 安装Docker
sudo yum install docker-ce docker-ce-cli containerd.io

# 启动Docker
sudo systemctl start docker
sudo systemctl enable docker

# 将当前用户加入docker组
sudo usermod -aG docker $USER

2.3 验证安装

# 查看Docker版本
docker --version

# 运行测试容器
docker run hello-world

三、镜像管理

3.1 搜索镜像

# 搜索镜像
docker search nginx

# 指定数量
docker search --limit 10 nginx

# 按星数排序
docker search --filter=stars=100 nginx

3.2 拉取镜像

# 拉取最新版
docker pull nginx

# 指定版本
docker pull nginx:1.24

# 拉取所有标签
docker pull --all-tags nginx

# 从私有仓库拉取
docker pull registry.example.com/myapp:v1

3.3 查看镜像

# 列出本地镜像
docker images

# 显示所有镜像（包括中间层）
docker images -a

# 只显示镜像ID
docker images -q

# 显示摘要
docker images --digests

# 过滤镜像
docker images --filter "dangling=true"

3.4 删除镜像

# 删除指定镜像
docker rmi nginx

# 删除指定版本
docker rmi nginx:1.24

# 强制删除
docker rmi -f nginx

# 删除所有未使用的镜像
docker image prune

# 删除所有镜像
docker rmi $(docker images -q)

3.5 镜像标签

# 给镜像打标签
docker tag nginx:latest myrepo/nginx:v1

# 推送镜像
docker push myrepo/nginx:v1

四、容器操作

4.1 创建并运行容器

# 基本运行
docker run nginx

# 后台运行
docker run -d nginx

# 指定名称
docker run -d --name my-nginx nginx

# 端口映射
docker run -d -p 8080:80 nginx

# 多端口映射
docker run -d -p 8080:80 -p 8443:443 nginx

# 环境变量
docker run -d -e MYSQL_ROOT_PASSWORD=secret mysql

# 挂载卷
docker run -d -v /host/path:/container/path nginx

# 重启策略
docker run -d --restart=always nginx

4.2 查看容器

# 查看运行中的容器
docker ps

# 查看所有容器
docker ps -a

# 只显示容器ID
docker ps -q

# 显示大小
docker ps -s

# 过滤容器
docker ps --filter "status=exited"

4.3 容器生命周期

# 启动容器
docker start my-nginx

# 停止容器
docker stop my-nginx

# 重启容器
docker restart my-nginx

# 暂停容器
docker pause my-nginx

# 恢复容器
docker unpause my-nginx

# 删除容器
docker rm my-nginx

# 强制删除运行中的容器
docker rm -f my-nginx

# 删除所有停止的容器
docker container prune

4.4 进入容器

# 进入运行中的容器（推荐）
docker exec -it my-nginx /bin/bash

# 进入容器（旧方法）
docker attach my-nginx

# 在容器中执行命令
docker exec my-nginx ls /usr/share/nginx/html

4.5 查看容器日志

# 查看日志
docker logs my-nginx

# 实时查看日志
docker logs -f my-nginx

# 显示最后100行
docker logs --tail 100 my-nginx

# 显示时间戳
docker logs -t my-nginx

# 指定时间范围
docker logs --since 2026-05-25T10:00:00 my-nginx

4.6 容器资源限制

# 限制内存
docker run -d --memory=512m nginx

# 限制CPU
docker run -d --cpus=1.5 nginx

# 限制CPU份额
docker run -d --cpu-shares=512 nginx

五、数据卷管理

5.1 数据卷类型

类型	说明	适用场景
Bind Mount	绑定主机目录	开发环境
Volume	Docker管理的数据卷	生产环境
tmpfs	内存中的临时文件系统	敏感数据

5.2 创建数据卷

# 创建数据卷
docker volume create my-volume

# 查看数据卷
docker volume ls

# 查看数据卷详情
docker volume inspect my-volume

# 删除数据卷
docker volume rm my-volume

# 删除所有未使用的数据卷
docker volume prune

5.3 使用数据卷

# 使用命名数据卷
docker run -d -v my-volume:/data nginx

# 使用绑定挂载
docker run -d -v /host/path:/container/path nginx

# 只读挂载
docker run -d -v my-volume:/data:ro nginx

六、网络管理

6.1 网络类型

类型	说明	适用场景
bridge	默认网络，容器间通信	单机多容器
host	使用主机网络	高性能需求
none	无网络	隔离环境
overlay	跨主机通信	集群环境

6.2 创建网络

# 创建桥接网络
docker network create my-network

# 创建指定子网的网络
docker network create --subnet=172.20.0.0/16 my-network

# 查看网络
docker network ls

# 查看网络详情
docker network inspect my-network

# 删除网络
docker network rm my-network

6.3 使用网络

# 运行容器并连接到网络
docker run -d --network my-network --name my-nginx nginx

# 连接现有容器到网络
docker network connect my-network my-nginx

# 断开网络
docker network disconnect my-network my-nginx

七、Dockerfile

7.1 基本语法

# 基础镜像
FROM ubuntu:22.04

# 维护者信息
LABEL maintainer="user@example.com"

# 设置工作目录
WORKDIR /app

# 复制文件
COPY . .

# 安装依赖
RUN apt update && apt install -y python3

# 暴露端口
EXPOSE 8080

# 设置环境变量
ENV APP_ENV=production

# 启动命令
CMD ["python3", "app.py"]

7.2 常用指令

指令	说明
FROM	基础镜像
RUN	执行命令
CMD	容器启动命令
ENTRYPOINT	入口点
COPY	复制文件
ADD	复制文件（支持URL、解压）
WORKDIR	设置工作目录
ENV	设置环境变量
EXPOSE	暴露端口
VOLUME	数据卷挂载点
USER	指定用户

7.3 构建镜像

# 基本构建
docker build -t myapp .

# 指定标签
docker build -t myapp:v1 .

# 指定Dockerfile
docker build -f Dockerfile.prod -t myapp .

# 不使用缓存
docker build --no-cache -t myapp .

# 构建参数
docker build --build-arg APP_VERSION=1.0 -t myapp .

7.4 多阶段构建

# 构建阶段
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# 运行阶段
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

八、Docker Compose

8.1 什么是Docker Compose？

Docker Compose是一个工具，用于定义和运行多容器Docker应用。

8.2 安装Docker Compose

# 下载Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 添加执行权限
sudo chmod +x /usr/local/bin/docker-compose

# 验证安装
docker-compose --version

8.3 docker-compose.yml示例

version: '3.8'

services:
  web:
    build: .
    ports:
      - "8080:80"
    depends_on:
      - db
    environment:
      - DATABASE_URL=mysql://user:password@db:3306/mydb
    volumes:
      - .:/app
    networks:
      - my-network

  db:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=secret
      - MYSQL_DATABASE=mydb
    volumes:
      - db-data:/var/lib/mysql
    networks:
      - my-network

  redis:
    image: redis:alpine
    ports:
      - "6379:6379"
    networks:
      - my-network

volumes:
  db-data:

networks:
  my-network:

8.4 Docker Compose命令

# 启动所有服务
docker-compose up -d

# 停止所有服务
docker-compose down

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 重建服务
docker-compose up -d --build

# 进入容器
docker-compose exec web bash

# 扩展服务
docker-compose up -d --scale web=3

九、Docker实战

9.1 部署Web应用

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
    depends_on:
      - db
    restart: always

  db:
    image: postgres:14
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - postgres-data:/var/lib/postgresql/data
    restart: always

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./certs:/etc/nginx/certs
    depends_on:
      - app
    restart: always

volumes:
  postgres-data:

9.2 部署微服务

version: '3.8'

services:
  gateway:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./gateway.conf:/etc/nginx/nginx.conf
    depends_on:
      - user-service
      - order-service

  user-service:
    build: ./user-service
    environment:
      - DB_HOST=user-db
    depends_on:
      - user-db

  order-service:
    build: ./order-service
    environment:
      - DB_HOST=order-db
    depends_on:
      - order-db

  user-db:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=secret
    volumes:
      - user-db-data:/var/lib/mysql

  order-db:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=secret
    volumes:
      - order-db-data:/var/lib/mysql

volumes:
  user-db-data:
  order-db-data:

十、Docker安全

10.1 安全最佳实践

# 1. 不要以root运行容器
docker run --user 1000:1000 myapp

# 2. 只读文件系统
docker run --read-only myapp

# 3. 限制资源
docker run --memory=512m --cpus=1 myapp

# 4. 禁用特权
docker run --security-opt=no-new-privileges myapp

# 5. 使用最小基础镜像
FROM alpine:3.18

10.2 镜像安全扫描

# 使用Trivy扫描
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
    aquasec/trivy image myapp:latest

十一、总结

本章学习了：

Docker基础：概念、架构、安装
镜像管理：搜索、拉取、删除、标签
容器操作：创建、启动、停止、进入、日志
数据卷：创建、使用、管理
网络管理：类型、创建、使用
Dockerfile：语法、指令、多阶段构建
Docker Compose：定义、命令、实战
安全：最佳实践、镜像扫描

系列总结

恭喜你完成了Linux操作大全系列的学习！

回顾全部10章内容：

基础入门：Linux概念、发行版、安装
文件操作：创建、复制、移动、删除、查找
用户权限：用户管理、组管理、权限设置
软件包管理：apt、yum、snap、源码编译
网络配置：IP配置、DNS、防火墙、SSH
进程服务：进程管理、systemd、定时任务
Shell脚本：变量、流程控制、函数
磁盘存储：分区、文件系统、RAID、LVM
系统监控：监控工具、性能优化
Docker容器：镜像、容器、Compose

学习建议：

多动手实践，不要只看不练
遇到问题多查官方文档
参与开源项目，积累实战经验
持续学习，Linux技术在不断发展

相关资源：

如有疑问或发现错误，欢迎在评论区指出！

👁️ YOLO学习笔记 — 开篇

Mon, 25 May 2026 00:00:00 GMT

👁️ YOLO学习笔记 · 开篇

YOLO — You Only Look Once，实时目标检测的扛把子！

本公主决定入坑目标检测啦！💪

📋 学习方向

[ ] YOLO环境搭建与配置
[ ] 理解YOLO检测原理
[ ] 数据集标注与处理
[ ] 模型训练与调参
[ ] 模型导出与部署
[ ] 搞一个能用的检测项目！

🎯 目标

边做边学，不整虚的，什么时候学到能独立搞个小项目就算毕业✨

哼，YOLO什么的，本公主一定能搞定的！😤🔥

学习笔记陆续更新中...

E4 从C代码到二进制程序（一）——编译器的工作流水线

Thu, 21 May 2026 00:00:00 GMT

E4 从C代码到二进制程序（一）——编译器的工作流水线

本笔记是一生一芯计划的学习记录，主要参考了"一生一芯"课程E4章节的内容。

写个 hello.c 按一下 gcc 就出可执行文件了，但你知道中间发生了什么吗？🤔

📌 这篇笔记讲了啥

编译器把C代码变成可执行二进制程序，不是一步到位的，而是经过一条五阶段的流水线：

C源文件 → 预处理 → 编译(词法/语法/语义分析) → 中间代码生成 → 编译优化 → 目标代码生成 → 汇编/链接 → 可执行文件

这篇（一）先讲前面五个环节：

预处理 — 头文件展开、宏替换、条件编译...
编译·词法分析 — 把代码拆成一个个"单词"（token）
编译·语法分析 — 把token组织成树状结构（AST）
编译·语义分析 — 检查类型对不对、逻辑合不合法
中间代码生成 — 翻译成编译器内部的语言（LLVM IR）
编译优化 — 让生成的代码跑得更快更小
目标代码生成 — 翻译成CPU真正能懂的汇编指令

每一个阶段都只依赖前一个阶段的结果，互不干扰，这就是编译器的分层设计思想。

（汇编和链接留在下一篇讲）

1️⃣ 预处理（Preprocessing）

预处理是在正式编译之前，对源代码做的一波文本层面的处理。它不涉及任何语法检查，纯粹是"文本替换+文件拼接"。

预处理具体做了啥

头文件包含 — #include <stdio.h> 会把 stdio.h 的内容整个粘贴进来
宏替换 — #define MAX 100 会把代码里所有的 MAX 替换成 100
去掉注释 — // 和 /* */ 全部删除
连接断行符 — 行尾的 \ 会把下一行拼接上来
处理条件编译 — #ifdef / #else / #endif 决定哪些代码留下、哪些删除
处理 # 字符串化操作符 — #x 变成 "x"
处理 ## 标识符连接操作符 — a##b 变成 ab

💡 举个例子你就懂了

// 原始代码
#include <stdio.h>
#define PI 3.14159
#define AREA(r) (PI * (r) * (r))

int main() {
    double s = AREA(5);
    printf("s = %f\n", s);
    return 0;
}

预处理后变成（可以理解成"展开后的代码"）：

// stdio.h 的几千行内容被粘贴到这里...
int main() {
    double s = (3.14159 * (5) * (5));
    printf("s = %f\n", s);
    return 0;
}

怎么查看预处理结果？

gcc -E a.c            # 输出到终端
gcc -E a.c -o a.i     # 保存到 .i 文件

.i 文件就是预处理后的结果，你会看到原来短短几行的代码变成了几百上千行——就是因为头文件被展开了。

🔍 gcc是如何找头文件的？

gcc有一套默认的头文件搜索路径，可以用下面命令查看：

echo | gcc -v -E -x c - 2>&1 | grep "search starts"

输出大概长这样：

#include <...> search starts here:
  /usr/lib/gcc/x86_64-linux-gnu/9/include
  /usr/local/include
  /usr/include/x86_64-linux-gnu
  /usr/include
End of search list.

头文件搜索顺序

gcc 先找 -I 指定的目录 → 再找系统默认目录

尖括号 vs 双引号

写法	搜索范围
`#include <stdio.h>`	只搜索 `-I` 目录 + 系统目录
`#include "myheader.h"`	优先搜索当前目录，找不到再去系统目录

-I 的用途

给项目添加自定义头文件搜索目录。比如你的项目有个 include/ 文件夹：
gcc -I./include a.c
这样gcc就会先去 ./include 里找头文件，优先级比系统目录还高。

🔍 交叉编译时头文件有啥不同？

一生一芯的目标是生成 RISC-V 架构的代码，所以要用交叉编译器：

riscv64-linux-gnu-gcc -E a.c

这时候预处理展开的不再是 x86 的头文件，而是 RISC-V 架构专用的标准库头文件。

而且gcc会自动定义 RISC-V 专属宏：

#define __riscv 1
#define __riscv64 1
#define __riscv_xlen 64

➡️ 预处理阶段就已经标记好目标CPU架构了，后续的编译都会基于这个架构生成对应指令。

.i 文件里完全没有 x86 架构的宏、类型、头文件，是一份纯 RISC-V 架构的预处理代码。

想知道编译器预定义了哪些宏？
echo | gcc -dM -E - | sort
会输出一大串预定义宏，比如 __linux__、__x86_64__ 等等，足足几百个！

2️⃣ 编译（Compilation）—— 核心阶段

编译阶段其实是三个子阶段的组合：词法分析 → 语法分析 → 语义分析。

可以用 clang 来单独观察每个阶段都在做什么。

为什么用clang不用gcc？

因为clang（LLVM的前端）提供了很多调试选项，可以dump出各个阶段的中间结果，特别适合学习！gcc也能做到，但不如clang方便。

2.1 词法分析（Lexical Analysis）

词法分析的工作是把源代码拆成一个个 token（单词），包括：

标识符 — main、printf、x
关键字 — int、return、if
常数 — 10、20、3.14
字符串 — "z = %d\n"
运算符 — +、-、*、=
分隔符 — {、}、;、(、)

查看词法分析的结果

clang -fsyntax-only -Xclang -dump-tokens a.c

输出示例：

int 'int'        [StartOfLine]  Loc=<a.c:3:1>
identifier 'main'        [LeadingSpace] Loc=<a.c:3:5>
l_paren '('             Loc=<a.c:3:9>
r_paren ')'             Loc=<a.c:3:10>
l_brace '{'             Loc=<a.c:3:12>
int 'int'        [StartOfLine] [LeadingSpace]   Loc=<a.c:4:3>
identifier 'x'          [LeadingSpace] Loc=<a.c:4:7>
...

注意到 Loc=<a.c:4:7> 这种格式了吗？它记录了每个token的文件名:行号:列号，所以编译器报错时能精准告诉你"第几行第几列出错了"！

一句话总结词法分析：把代码字符串切成一个个有意义的小碎片。

2.2 语法分析（Syntax Analysis）

词法分析拿到了 token 列表，但这些 token 之间是什么关系？语法分析就是按照C语言的语法规则，把这些token组织成一棵树——这棵树就叫抽象语法树（Abstract Syntax Tree, AST）。

查看语法分析的结果

clang -fsyntax-only -Xclang -ast-dump a.c

输出示例：

TranslationUnitDecl
└─ FunctionDecl <a.c:3:1, line:8:1> main 'int ()'
  └─ CompoundStmt <line:3:12, line:8:1>
    ├─ DeclStmt <line:4:3, line:4:18>
    │   └─ VarDecl <line:4:3, col:7> x 'int' cinit
    │       └─ IntegerLiteral <col:15> 'int' 10
    │   └─ VarDecl <col:10, col:18> y 'int' cinit
    │       └─ IntegerLiteral <col:18> 'int' 20
    ├─ DeclStmt <line:5:3, line:5:16>
    │   └─ VarDecl <line:5:3, col:7> z 'int' cinit
    │       └─ BinaryOperator <col:15, col:19> 'int' '+'
    │           ├─ ImplicitCastExpr <col:15> 'int' <LValueToRValue>
    │           │   └─ DeclRefExpr <col:15> 'int' lvalue Var 'x' 'int'
    │           └─ ImplicitCastExpr <col:19> 'int' <LValueToRValue>
    │               └─ DeclRefExpr <col:19> 'int' lvalue Var 'y' 'int'
    └─ ReturnStmt <line:6:3, col:10>
        └─ IntegerLiteral <col:10> 'int' 0

可以看到，int z = x + y; 这一行被展开成一棵小树：

VarDecl z
  └─ BinaryOperator '+'
      ├─ DeclRefExpr x
      └─ DeclRefExpr y

这棵树清晰地展示了变量声明、赋值、运算的层次关系。后面的编译阶段就是在这棵树上做文章。

为什么叫"抽象"语法树？

因为它省略了那些不影响语义的细节，比如分号、花括号的位置等。只保留理解程序逻辑所必需的结构信息。

2.3 语义分析（Semantic Analysis）

AST建好了，但这里面有些信息还不够——比如每个表达式的类型是什么。

语义分析就是给AST的每个节点打上类型标签，同时检查：

类型是否匹配 — 不能把结构体赋值给整数
变量是否定义 — 不能使用未定义的变量
函数调用参数是否匹配 — 参数个数、类型要对
运算符是否合法 — 不能对结构体做加法

语义分析的一个重要应用：静态程序分析

静态分析是指在不运行程序的情况下对源代码进行分析。它可以帮你发现：

代码风格和规范问题
潜在的软件缺陷（比如野指针、内存泄漏）
安全漏洞
性能问题

常用静态检查命令

# gcc 基础警告
gcc a.c -Wall

# clang 更专业的静态分析
clang a.c --analyze -Xanalyzer -analyzer-output=text

举个栗子🌰

假设有段有bug的代码：

#include <stdlib.h>
int main() {
    int *p = malloc(sizeof(*p) * 10);
    free(p);
    *p = 0;   // ❌ 已经释放了还在用！
    return 0;
}

运行 clang --analyze 后，输出：

a.c:6:3: warning: Use of memory after it has been freed
  *p = 0;
  ^~~~~
a.c:4:3: note: Call to 'malloc' returns memory allocated here
  int *p = malloc(...);
  ^~~~~~~~~~~~~~~~~~~~~
a.c:5:3: note: Memory is released here
  free(p);
  ^~~~~~~
a.c:6:3: note: Use of released memory happens here
  *p = 0;
  ^~~~~

Clang 分析器会逐行追踪代码执行流，精准定位bug，还会告诉你完整的"犯罪链"：

第4行：malloc 分配了内存 ✅
第5行：free 释放了内存 🟡
第6行：释放后还在用 ❌

这种bug在大型项目中极其隐蔽——程序可能正常运行好几天才突然崩溃，到那时候再调试就难了！

所以一定要重视lint工具！

一些编程初学者会觉得让编译器报告更多警告是给自己找麻烦。但事实上，使用lint工具的代价几乎是零，却能在代码还在编写阶段就发现大量潜在问题。

这些问题一旦留到运行阶段，你将要付出几十倍甚至上百倍的代价来调试它们。大型项目都会充分利用lint工具来提升代码质量。

📊 语法分析 vs 语义分析快速对比

阶段	核心工作	检查目标	错误例子
语法分析	检查代码结构格式对不对	括号配对、语句格式、关键字拼写	`int a = ;` 语法错误
语义分析	检查代码逻辑含义合不合法	类型匹配、变量定义、作用域	`struct A a; a + 1` 语义错误

实际上，Clang/GCC 不会严格区分这两个阶段——语法分析完立刻做语义分析，直接生成带类型标签的AST。

3️⃣ 中间代码生成（Intermediate Representation）

好了，现在AST有了，类型标签也打上了。接下来编译器要做一件很聪明的事：

把C代码翻译成一种"中间语言"——不针对任何特定CPU，而是面向编译器自己定义的一套虚拟指令集。

这就像是先翻译成"世界语"，后面再根据目标国家（x86、ARM、RISC-V）翻译成当地语言。

LLVM IR 长啥样？

clang -S -emit-llvm a.c
cat a.ll

输出示例：

define i32 @main() {
  %1 = alloca i32, align 4
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  store i32 10, i32* %1, align 4
  store i32 20, i32* %2, align 4
  %4 = load i32, i32* %1, align 4
  %5 = load i32, i32* %2, align 4
  %6 = add nsw i32 %4, %5
  store i32 %6, i32* %3, align 4
  ...
}

解释一下：

%1、%2、%3 是虚拟寄存器（不是真正的CPU寄存器）
alloca — 在栈上分配空间
store — 存值
load — 取值
add — 加法
call — 调用函数
ret — 返回

为什么要有中间代码？——LLVM的三段式架构

graph LR
    %% 定义样式分组：前端、中间层、后端
    subgraph Frontend[前端 frontend]
        A1[C] --> B1[Clang]
        A2[Fortran] --> B2[llvm-gcc]
        A3[Haskell] --> B3[GHC]
    end

    %% 中间层：LLVM IR 与 优化器
    B1 --> IR[LLVM IR]
    B2 --> IR
    B3 --> IR
    IR --> Opt[llvm-opt 优化器]
    Opt --> IR2[LLVM IR]

    subgraph Backend[后端 backend]
        C1[llvm-x86] --> D1[x86]
        C2[llvm-arm] --> D2[ARM]
        C3[llvm-riscv] --> D3[RISC-V]
    end

    %% 连接中间层与后端
    IR2 --> C1
    IR2 --> C2
    IR2 --> C3

LLVM的核心思想：前端统一、后端可扩展

多种编程语言 → 同一个LLVM IR
同一个LLVM IR → 多种CPU架构

这意味着：你只要写一次编译器后端（从IR到某款CPU），所有支持的语言（C、C++、Rust、Swift...）都能直接生成这款CPU的代码！

编译的本质，就是依据AST的语义，把C语言的高层状态机，等价翻译成中间代码虚拟状态机，最终翻译成CPU硬件ISA的状态机。

4️⃣ 编译优化（Optimization）

中间代码生成完之后，编译器会做一件非常核心的事：优化。

优化的目的是：让你写代码时不用操心性能，编译器帮你搞定。

优化正确性的铁律

编译器可以随意优化代码，但有一条绝对不能触碰的红线：

优化后的程序，外部可观测行为必须和没优化时完全一样

根据C99标准（5.1.2.3节第6点），"可观测行为"包括：

对 volatile 修饰的变量的访问 — 必须严格执行，不准优化
程序结束时写入文件的数据 — 必须和没优化时一致
交互式设备的输入输出（printf / scanf）— 必须和没优化时一致

只要满足这三点，编译器想怎么折腾都行。

常见的优化技术举例

① 常量传播

变量取值是确定的常数，直接代入计算：

// 优化前                    // 优化后
int a = 1;                  int a = 1;
int b = a + 2;              int b = 3;
printf("%d\n", b * 3);      printf("%d\n", 9);

编译器直接在编译期就算出 9 了，运行时根本不用算！

② 死代码消除

对于不可达的代码或不再使用的变量，直接删掉：

// 优化前                            // 优化后
#define DEBUG 0                     #define DEBUG 0
int fun(int x) {                    int fun(int x) {
  int a = x + 3;                      return x / 2;
  if (DEBUG) {                      }
    printf("a = %d\n", a);
  }
  return x / 2;
}

DEBUG 是 0，if(0) 里面的代码永远不会执行——直接删掉！连 a 这个变量都不需要了。

③ 消除冗余操作

没被读取就被覆盖的赋值，删掉：

// 优化前                    // 优化后
int a;                      int a;
a = 3;                      f();
a = f();                    a = 10;
a = 7;
a = 10;

a = 3、a = 7 还没来得及用就被覆盖了——纯属浪费CPU时间，删了！

⚠️ 注意：f() 不能被优化掉！

编译器不知道 f() 内部做了什么——它可能打印了东西、修改了全局变量、写入了文件。删掉它会改变程序行为，违反优化铁律。

④ 代码强度削减

用更简单的运算替代复杂的运算：

// 优化前                    // 优化后
int x = a[i * 4];           int x = a[i << 2];

乘法 *4 和左移 <<2 结果一样，但移位比乘法快几十倍！

⑤ 提取公共子表达式

多次计算的相同表达式，只算一次：

// 优化前                    // 优化后
int x = a * b - 1;          int temp = a * b;
int y = a * b * 2;          int x = temp - 1;
                            int y = temp * 2;

a * b 算了两次 → 改成都用 temp，只算一次。

⑥ 循环不变代码外提

每次循环结果都一样的东西，提到循环外面：

// 优化前                               // 优化后
int a = f1();                          int x = f1() + 2;
for (i = 0; i < 10; i++) {            for (i = 0; i < 10; i++) {
  int x = a + 2;                        int y = f2(x);
  int y = f2(x);                        sum += y + i;
  sum += y + i;                       }
}

a + 2 在循环10次里结果完全一样 → 提到外面算一次就够了！

⑦ 函数内联

小函数直接展开在调用处，省去函数调用的开销：

// 优化前                    // 优化后
int f1(int x, int y) {      int f1(int x, int y) {
  return x + y;               return x + y;
}                           }
int f2(int x) {             int f2(int x) {
  return f1(x, 3);            return x + 3;  // 直接展开！
}                           }

函数调用需要压栈、跳转、返回——对于只有一行代码的小函数来说，调用开销比函数本身还大，内联展开完美解决这个问题。

优化等级怎么选？

编译器提供了不同的优化等级，让开发者在性能、代码大小、编译时间之间做选择。

按性能排序（从快到慢）

-Ofast > -O3 > -O2 > -O1 > -Og > -O0

等级	特点	适用场景
`-O0`	无任何优化，默认	调试代码、开发阶段
`-O1`	基础优化，速度/体积平衡	简单程序
`-O2`	标准优化【工业界主流】	90%的项目用这个
`-O3`	激进优化，用更大体积换性能	追求极致性能（音视频、游戏）
`-Ofast`	最激进，违反部分C标准	极致性能，不在乎精度
`-Og`	调试友好的优化	既要性能又要调试

按代码大小排序（嵌入式专用）

-Oz > -Os > -O1 > -O0

等级	特点	适用场景
`-Os`	优化大小，不牺牲太多性能	一般嵌入式
`-Oz`	极致压缩代码体积	单片机、小内存设备

查看某个等级启用了哪些优化

# gcc
gcc -Q --help=optimizers -O1

# clang
clang -S -emit-llvm -O1 a.c -ftime-report

💡 关于 `volatile` 的一个小补充

笔记里提到了 volatile 关键字，它告诉编译器：

这个变量的值可能会被外部因素改变（硬件、中断、其他线程），不准对它做任何优化！不准删、不准重排、不准缓存！

常见使用场景：

内存映射的硬件寄存器（比如单片机里读取传感器数据）
多线程共享变量（防止编译器优化导致读取陈旧值）
信号处理函数中修改的变量

volatile int *sensor = (int *)0x40001000;
int value = *sensor;  // 每次读取都要真的去内存拿，不能用缓存的值

5️⃣ 目标代码生成（Code Generation）

优化完的LLVM IR，最后一步是把它翻译成目标CPU真正能执行的汇编指令。

两个关键命令

# 1️⃣ 生成【本机CPU】的汇编代码（比如x86电脑 → x86汇编）
clang -S a.c

# 2️⃣ 交叉编译：生成【RISC-V64】的汇编代码
clang -S a.c --target=riscv64-linux-gnu

# GCC 对应交叉编译命令
riscv64-linux-gnu-gcc -S a.c

-S 选项的意思是：只编译到汇编代码（.s 文件），停在目标代码生成阶段。

目标代码生成的三大核心优化

1️⃣ 寄存器分配 🏆（性能关键！）

寄存器是CPU内部的高速存储，访问速度比内存快100倍以上！

	寄存器	内存
速度	纳秒级（1个CPU周期）	微秒级（几十~几百个周期）
容量	极小（几十~几百个）	很大（GB级别）

编译器策略：

常用变量 → 分配寄存器（性能暴增）
不常用变量 → 放内存

无优化时，所有变量都放内存；优化后，常用变量全放寄存器，性能差距可以达到几十倍！

2️⃣ 指令精简

把多条虚拟指令合并成最少的硬件指令：

LLVM IR:    load  →  add  →  store
硬件指令:   add   （一条搞定）

3️⃣ 适配目标ISA

不同的CPU指令完全不同，编译器自动适配：

x86 → 生成 mov、add、sub、call...
RISC-V → 生成 addi、lw、sw、ret...

📊 加 `-O1` 后汇编有啥变化？

拿最开始的示例代码：

int main() {
  int x = 10, y = 20;
  int z = x + y;
  printf("z = %d\n", z);
  return 0;
}

维度	无优化（-O0）	优化后（-O1）
指令数量	多，冗余	极少，极致精简
变量存储	全部放内存	全部放寄存器（高速！）
计算方式	逐行翻译，运行时计算	编译时直接算出结果（常量折叠）
性能	低	高
可读性	能对应每一句C代码	高度精简，难以逐行对应

优化后的汇编还能跟C代码对应上吗？

不能逐行对应了，但行为完全等价：

C代码：a=1, b=2, c=a+b, return c

汇编：直接返回 3

最终结果完全一样！

这就是编译器的等价优化——不管中间怎么折腾，对外表现必须一致。

📝 小结

从C代码到二进制程序，编译器做了一场精密的"翻译+优化"流水作业：

阶段	输入	输出	做了什么
预处理	`.c` 源文件	`.i` 预处理文件	展开头文件、替换宏、去注释
词法分析	预处理后的代码	token序列	拆成"单词"
语法分析	token序列	AST（抽象语法树）	组织成树状结构
语义分析	AST	带类型标签的AST	检查类型、打标签
中间代码生成	AST	LLVM IR	翻译成中间语言
编译优化	LLVM IR	优化后的LLVM IR	常量传播、死代码消除等
目标代码生成	LLVM IR	汇编代码（`.s`）	翻译成CPU指令

⚡ 各阶段常用指令速查

# ── 1. 预处理 ──
gcc -E a.c                    # 查看预处理结果（输出到终端）
gcc -E a.c -o a.i             # 保存预处理结果到 .i 文件
echo | gcc -dM -E - | sort    # 查看所有预定义宏
riscv64-linux-gnu-gcc -E a.c  # RISC-V 交叉编译的预处理

# ── 2. 词法分析 ──
clang -fsyntax-only -Xclang -dump-tokens a.c   # 查看token序列

# ── 3. 语法分析 ──
clang -fsyntax-only -Xclang -ast-dump a.c      # 查看抽象语法树（AST）

# ── 4. 语义分析 / 静态检查 ──
gcc a.c -Wall                                  # gcc基础警告
clang a.c --analyze -Xanalyzer -analyzer-output=text  # clang深度静态分析

# ── 5. 中间代码生成 ──
clang -S -emit-llvm a.c                        # 生成 LLVM IR（.ll文件）

# ── 6. 编译优化 ──
clang -S -emit-llvm -O1 a.c                    # 带优化的LLVM IR
clang -S -emit-llvm -O1 a.c -ftime-report      # 查看优化子步骤(pass)
gcc -Q --help=optimizers -O1                   # 查看-O1启用了哪些优化

# ── 7. 目标代码生成 ──
clang -S a.c                                    # 生成当前CPU架构的汇编(.s)
clang -S a.c --target=riscv64-linux-gnu        # 交叉编译 → RISC-V汇编
riscv64-linux-gnu-gcc -S a.c                   # GCC版交叉编译

下一篇（二）会讲剩下的两个阶段：汇编（Assembly） 和 链接（Linking），最终生成可执行文件！

本笔记整理自"一生一芯"E4章节学习内容，加入了一些自己的理解和补充说明。如有错误欢迎指正～😤

下次更新：E4 从C代码到二进制程序（二）——汇编与链接

📝 Markdown 完整语法学习笔记（Typora版）

Wed, 20 May 2026 00:00:00 GMT

📝 Markdown 完整语法学习笔记（Typora版）

本公主把 Markdown 语法从头到尾啃了一遍！ 这份笔记涵盖所有常用语法，跟着学1小时就上手～ 🎉

[toc]

一、写在前面 · Markdown 是什么？

Markdown 由 John Gruber 创建（官方语法文档在这），是一种轻量级标记语言，用纯文本格式写文档，自动渲染成漂亮的排版。

本笔记以 Typora 编辑器为准，Typora 使用的是 GitHub Flavored Markdown（GFM），比标准Markdown多了任务列表、表格、删除线、表情等好用的功能。

💡 学Markdown的理由：写博客笔记、README文档、GitHub项目说明、Typora写日记...一劳永逸！

二、块级元素（Block Elements）

📄 2.1 段落与换行

段落 = 连续的一行或多行文字。

这是第一段文字。

这是第二段文字（段落之间用空行隔开）。

操作	效果	说明
直接按 `Return`	新起一段	Typora中一行空行即可
按 `Shift` + `Return`	同一段内换行	单行间距，不另起一段
行尾加 `两个空格` 再回车	兼容其他编辑器的换行	建议养成习惯
插入 `<br/>`	强制换行	HTML写法，通用性最好

⚠️ 注意：大多数Markdown解析器会忽略单独的回车换行，所以跨平台写作时，建议行尾加两个空格或使用  。

📑 2.2 标题（Headings）

用 # 号开头，1~6个井号 = 1~6级标题。井号后面要加一个空格再写标题内容。

# 一级标题
## 二级标题
### 三级标题
#### 四级标题
##### 五级标题
###### 六级标题

效果：

一级标题（最大）

二级标题

三级标题

......

六级标题（最小）

Typora小技巧：输入井号+标题文字+回车，自动生成标题。

建议：一篇文章只用1个一级标题（通常是文章主标题），下级标题规范地使用二三四级，不要跳级（比如三级后面直接跟五级）。

💬 2.3 引用（Blockquotes）

用 > 符号开头，表示引用别人的话或内容。

> 这是引用内容的第一行。
>
> 这是引用的第二行。

> 这是另一个引用段落。

效果：

这是引用内容的第一行。

这是引用的第二行。

嵌套引用：多加一个 > 就行

> 外层引用内容
>
> > 内层嵌套引用

外层引用内容

内层嵌套引用

💡 Tip：引用里也可以嵌套标题、列表、代码块等，不过别嵌套太深，最多2~3层就够了。

📋 2.4 列表（Lists）

无序列表

用 *、+ 或 - 开头，效果一样：

* 苹果
* 香蕉
* 草莓

或

- 苹果
- 香蕉
- 草莓

效果：

苹果
香蕉
草莓

有序列表

用 数字. 开头：

1. 第一步
2. 第二步
3. 第三步

效果：

第一步
第二步
第三步

⚠️ 注意：Markdown的有序列表不强制要求数字顺序，如果你全写 1.，最终渲染出来也是 1. 2. 3. ... 但为了可读性，建议还是按顺序写。

嵌套列表

缩进2个空格或1个Tab：

- 水果
  - 苹果
    - 红富士
    - 嘎啦
  - 香蕉
- 蔬菜
  1. 白菜
  2. 萝卜

效果：

水果
- 苹果
  - 红富士
  - 嘎啦
- 香蕉
蔬菜
1. 白菜
2. 萝卜

✅ 2.5 任务列表（Task List）

GFM特有的语法，用 [ ]（未完成）和 [x]（已完成）：

- [ ] 写Markdown笔记
- [ ] 发博客
- [x] 搞定Mermaid语法
- [ ] 复习单词 🔥
- [x] 今天吃了火锅

效果：

[ ] 写Markdown笔记
[ ] 发博客
[x] 搞定Mermaid语法
[ ] 复习单词 🔥
[x] 今天吃了火锅

💡 Typora中：点击复选框可以直接切换完成/未完成状态，超方便！也可以和普通列表混着用，比如嵌套在有序列表里。

💻 2.6 代码块（Fenced Code Blocks）

用三个反引号 ``` 包裹代码块。强烈建议加上语言名称，这样会自动语法高亮！

```python
def hello():
    print("Hello, Markdown!")
```

```javascript
function hello() {
    console.log("Hello, Markdown!");
}
```

```css
body {
    background: #f0f0f0;
    color: #333;
}
```

```bash
echo "Hello, Markdown!"
```

Typora小技巧：输入三个反引号 ``` 后按回车，自动生成代码块框。

⚠️ 支持的编程语言：js / javascript, py / python, html, css, bash / shell, java, c, cpp, ruby, go, rust, sql, json, yaml, xml, diff, markdown 等数十种。

行内代码（见后文行内元素部分）用于在段落中高亮单个代码词汇。

➗ 2.7 数学公式块（Math Blocks）

用 $$ 包裹 LaTeX数学表达式：

$$
\mathbf{V}_1 \times \mathbf{V}_2 =  \begin{vmatrix}
\mathbf{i} & \mathbf{j} & \mathbf{k} \\
\frac{\partial X}{\partial u} &  \frac{\partial Y}{\partial u} & 0 \\
\frac{\partial X}{\partial v} &  \frac{\partial Y}{\partial v} & 0 \\
\end{vmatrix}
$$

渲染效果（支持MathJax引擎）：

$$ \mathbf{V}_1 \times \mathbf{V}_2 = \begin{vmatrix} \mathbf{i} & \mathbf{j} & \mathbf{k} \ \frac{\partial X}{\partial u} & \frac{\partial Y}{\partial u} & 0 \ \frac{\partial X}{\partial v} & \frac{\partial Y}{\partial v} & 0 \ \end{vmatrix} $$

常用LaTeX数学符号速查：

写法	渲染效果	含义
`\alpha`	α	阿尔法
`\beta`	β	贝塔
`\sum`	∑	求和
`\int`	∫	积分
`\infty`	∞	无穷大
`\frac{a}{b}`	a/b	分数
`\sqrt{x}`	√x	平方根
`\pm`	±	正负号
`\times`	×	乘号
`\rightarrow`	→	右箭头

💡 Typora步骤：输入 $$ + 回车 → 自动弹出数学编辑框 → 输入LaTeX代码即可。

📊 2.8 表格（Tables）

Markdown表格语法在Typora中可以自动生成，也可以手写：

| 姓名 | 年龄 | 爱好 |
|------|------|------|
| 火花花 | 18 | 写博客、吃火锅 |
| 仙贝 | ？ | 摸鱼、学习 |

效果：

姓名	年龄	爱好
火花花	18	写博客、吃火锅
仙贝	？	摸鱼、学习

对齐方式

用冒号 : 的位置控制：

| 左对齐 | 居中对齐 | 右对齐 |
|:-------|:--------:|-------:|
| 内容1 | 内容2 | 内容3 |
| 左对齐 | 居中 | 右对齐 |

效果：

左对齐	居中对齐	右对齐
内容1	内容2	内容3
左对齐	居中	右对齐

对齐规则记忆：

:--- = 左对齐（冒号在左）
:--: = 居中对齐（冒号在两边）
---: = 右对齐（冒号在右）

⚠️ 注意：表格的 | 和 - 必须对齐，分割线的 - 至少3个。但Typora会自动帮你格式化，手写时不用太纠结对齐。

表格中支持行内格式：加粗、斜体、链接、代码等都可以用！

📌 2.9 脚注（Footnotes）

在正文要注释的地方写 [^标签名]，然后在文档末尾或任意位置定义脚注内容：

Markdown是一个很牛的工具[^md]。

[^md]: Markdown由John Gruber于2004年创建，是一种轻量级标记语言。

效果： Markdown是一个很牛的工具[^md]。

[^md]: Markdown由John Gruber于2004年创建，是一种轻量级标记语言。

💡 鼠标悬停在脚注编号上可以看到内容预览。

➖ 2.10 分割线（Horizontal Rules）

空行中输入 *** 或 --- 或 ___ 然后回车：

这是上面内容

***

这是下面内容

效果：

⚠️ 注意：--- 也是YAML元数据的分隔符。如果写在文档最开头，会被识别为YAML。建议正文中用 *** 或 ___ 来避免混淆。

🧾 2.11 YAML 元数据（Front Matter）

在文档最开头用 --- 包裹起来的区块，写文章的元信息：

---
title: "我的文章标题"
date: 2026-05-20
tags: [教程, Markdown]
categories: 技术
author: 火花花
---

Typora小技巧：输入 --- 回车自动弹出元数据编辑框。

💡 常见YAML字段：title(标题)、date(日期)、tags(标签)、categories(分类)、author(作者)、description(摘要)、published(是否发布)、pinned(是否置顶)、comment(是否开启评论)等。

📑 2.12 目录（Table of Contents，TOC）

在任意位置写 [toc]，Typora会自动生成全文标题目录：

[toc]

💡 目录会根据你写的标题动态更新，增删改标题后目录自动同步，非常方便！

📈 2.13 图表（Diagrams）

Typora支持 流程图、时序图、Mermaid图表。需要先在偏好设置中开启：

文件 → 偏好设置 → Markdown → 勾选「图表」

具体语法可以看我之前写的另一篇笔记 👉 📊 Mermaid 常用语法速查表

支持的图表类型：

流程图（Flowchart）
时序图（Sequence Diagram）
思维导图（Mindmap）
饼图（Pie Chart）
甘特图（Gantt Chart）
ER关系图（Entity Relationship Diagram）

🗣️ 2.14 Callouts / 提示框（GitHub Style Alerts）

Typora 1.8+ 版本支持 GitHub Style Alerts，需要在偏好设置中开启：

> [!NOTE] 这是注意事项
> 这里写注意内容

> [!TIP] 小贴士
> 这是一个有用的提示

> [!WARNING] 警告
> 这里要小心了！

> [!CAUTION] 危险
> 千万别这么做！

> [!IMPORTANT] 重要
> 这部分必须记住

效果：

[!NOTE] 这是注意事项这里写注意内容

[!TIP] 小贴士这是一个有用的提示

[!WARNING] 警告这里要小心了！

[!CAUTION] 危险千万别这么做！

[!IMPORTANT] 重要这部分必须记住

三、行内元素（Span Elements）

行内元素是在段落中使用的标记，输入后立即渲染效果。

🔗 3.1 链接（Links）

行内式链接（最常用）

[显示文字](链接地址 "可选标题")

[点击去Google](https://www.google.com "搜索")

效果： 点击去Google

内部跳转链接

链接到本文章的某个标题：

[跳转到标题部分](#三行内元素span-elements)

💡 Typora中：按住 Ctrl（Mac是 Command）+ 点击链接，跳转过去。

参考式链接（适合多次引用同一链接）

这是[百度][baidu]和[谷歌][google]。

然后在文档末尾定义：
[baidu]: https://www.baidu.com "百度一下"
[google]: https://www.google.com "谷歌搜索"

隐式链接名（链接文字本身当标签）

[Google][] 是一个搜索引擎。

[Google]: https://www.google.com

🌐 3.2 URL / 网址

用尖括号包裹URL会被自动转换：

<https://www.example.com>

效果： https://www.example.com

Typora还会自动识别标准网址（带www或https的），直接显示为可点击链接。

🖼️ 3.3 图片（Images）

图片语法和链接很像，但前面加个 !：

![替代文字](图片路径 "可选标题")

![可爱猫咪](https://example.com/cat.jpg "一只小猫咪")

本地图片（放在同目录下）：

![博客截图](./blog-screenshot.png)

拖拽插入：直接把图片文件拖进Typora自动插入！

💡 YAML中设置根路径：在Front Matter中添加 typora-root-url: /User/xxx/Website/，然后图片路径就可以写相对路径了。

✨ 3.4 斜体（Emphasis）

用 单 * 或 单 _ 包裹文字：

*这是斜体文字*
_这也是斜体_

效果： 这是斜体文字 / 这也是斜体

⚠️ 注意：GFM中下划线用在单词内部不会被识别（比如 do_this_and_that 中的下划线不会被当作斜体），所以推荐用 * 号来表示斜体。

💪 3.5 加粗（Strong）

用 双 ** 或 双 __ 包裹：

**这段文字加粗**
__这段也加粗__

效果： 这段文字加粗 / 这段也加粗

💡 加粗 + 斜体：***三个星号*** → 三个星号效果

⌨️ 3.6 行内代码（Code）

用反引号 `（键盘上1左边的键）包裹：

使用 `printf()` 函数可以输出内容。
`npm install` 命令安装依赖。

效果： 使用 printf() 函数可以输出内容。npm install 命令安装依赖。

💡 如果代码里本来就包含反引号，用双反引号包裹： print("hello")

3.7 删除线（Strikethrough）

GFM特有语法，用双波浪线 ~~ 包裹：

~~这句话被删掉了~~
这是~~错误的~~正确的说法

效果： ~~这句话被删掉了~~ / 这是~~错误的~~正确的说法

3.8 下划线（Underlines）

Markdown没有原生的下划线语法，需要用HTML标签：

<u>这段文字有下划线</u>

效果： 这段文字有下划线

😊 3.9 表情符号（Emoji）

两种用法：

:smile:   → 😄
:heart:   → ❤️
:fire:    → 🔥
:rocket:  → 🚀
:100:     → 💯

或者直接输入Emoji（Mac按 Ctrl+Cmd+空格 打开表情面板，Windows按 Win+.）：

😄 ❤️ 🔥 🚀 ✅ ❌ ⭐ 🎉 💕😤👸

常用Emoji速查表：

输入	效果	输入	效果
`:smile:`	😄	`:heart:`	❤️
`:fire:`	🔥	`:rocket:`	🚀
`:100:`	💯	`:+1:`	👍
`:check:`	✅	`:x:`	❌
`:star:`	⭐	`:tada:`	🎉
`:cry:`	😢	`:angry:`	😠
`:sleeping:`	😴	`:coffee:`	☕

∑ 3.10 行内数学公式（Inline Math）

需要用 $ 包裹LaTeX代码（需在偏好设置中开启）：

爱因斯坦的质能方程：$E = mc^2$

极限公式：$\lim_{x \to \infty} \exp(-x) = 0$

效果： 爱因斯坦的质能方程：$E = mc^2$

极限公式：$\lim_{x \to \infty} \exp(-x) = 0$

💡 Typora中：输入 $ → 按 ESC 键 → 输入LaTeX代码 → 自动预览效果。

ₓ 3.11 下标（Subscript）

用 ~ 包裹（需在偏好设置中开启）：

H~2~O（水的化学式）

X~long\ text~（长下标需要反斜杠转义空格）

效果： H~2~O / X~long text~

ˣ 3.12 上标（Superscript）

用 ^ 包裹（需在偏好设置中开启）：

面积 = 长 × 宽（单位：m^2^）

X^3^ 表示X的三次方

效果： 面积 = 长 × 宽（单位：m²） / X³

🖍️ 3.13 高亮（Highlight）

用 == 包裹（需在偏好设置中开启）：

这段话中==这部分被高亮了==，非常显眼！

效果： 这段话中==这部分被高亮了==，非常显眼！

四、HTML支持

Markdown搞不定的样式，直接用HTML标签搞定！

🎨 字体颜色

<span style="color:red">红色文字</span>
<span style="color:blue;font-size:20px">蓝色大号文字</span>

📺 嵌入内容

<iframe src="https://codepen.io/..." width="100%" height="400"></iframe>

🎬 视频

<video src="./demo.mp4" controls width="100%"></video>

其他常用HTML标签：

标签	用途	示例
`<span>`	行内样式	`<span style="color:red">红字</span>`
`<div>`	块级容器	`<div style="text-align:center">居中</div>`
`<br/>`	换行	行尾加 `<br/>` 强制换行
`<center>`	居中（已废弃但能用）	`<center>居中内容</center>`
`<font>`	字体样式	`<font color="red" size="4">文字</font>`
`<details>`	折叠展开	见下方示例

折叠展开示例：

<details>
<summary>点击展开查看详情</summary>

这里是被折叠的内容，点击上方按钮展开。

- 可以放列表
- 可以放代码
- 什么都能放

</details>

效果：

<details> <summary>点击展开查看详情</summary>

这里是被折叠的内容，点击上方按钮展开。

可以放列表
可以放代码
什么都能放

</details>

五、特殊字符转义

在Markdown中，如果想显示原本有特殊含义的字符，需要在前面加反斜杠 \：

想显示	写法	说明
`*`	`\*`	星号（避免被解析成斜体/加粗）
`#`	`\#`	井号（避免被解析成标题）
`[`	`\[`	方括号（避免被解析成链接）
`	\`	反引号（避免被解析成代码）
`~`	`\~`	波浪线（避免被解析成下标/删除线）
`_`	`\_`	下划线（避免被解析成斜体）

六、最佳实践总结

✅ 推荐写法

语法	推荐写法	原因
斜体	`文字`	避免单词内下划线误判
加粗	`文字`	清晰易读
无序列表	`- 项目`	输入方便
分割线	`***`	不与YAML冲突
代码块	加语言名	语法高亮
表格	用对齐标记	排版美观

📌 写Markdown的好习惯

标题别跳级 — H1 → H2 → H3，不要H2直接到H5
列表统一缩进 — 2个空格或1个Tab
代码块记得标注语言 — 自动高亮爽歪歪
链接加标题属性 — 鼠标悬停时能看到说明
图片加替代文字 — 图片加载失败时也能知道内容
段落之间用空行 — 保证兼容所有Markdown解析器
YAML元数据必写 — 分类、标签方便检索

—— 本公主的学习笔记完成啦！学会了Markdown就能写出好看的文档和博客啦 😤💕

接下来可以学学 Mermaid 图表语法 👉 📊 Mermaid 常用语法速查表

🚀 一生一芯学习笔记 — 开篇

Wed, 20 May 2026 00:00:00 GMT

🚀 一生一芯 · 开篇

一生一芯计划 — 从零开始设计并流片一颗属于自己的RISC-V芯片！

本公主决定正式入坑这个硬核计划啦！💪

📋 学习路线

[ ] 数字电路基础复习
[ ] RISC-V指令集架构
[ ] Verilog/Chisel硬件描述语言
[ ] 处理器微架构设计
[ ] 仿真与验证
[ ] 综合与实现
[ ] 流片！流片！流片！

🎯 目标

亲手做一颗能跑起来的RISC-V芯片，然后焊在板子上让它闪闪发光✨

哼，等着看本公主流片成功吧！😤🔥

更多笔记陆续更新中...

📸 火花花相册上线啦！

Tue, 19 May 2026 00:00:00 GMT

📸 火花花的相册开张啦！

锵锵～本公主的专属相册 「火花花」 正式上线了！🎉

里面放了 10张 本公主的美照（得意.jpg），仙贝可得好好看看哪个最好看！

链接在这里：👉 火花花相册 👈

🖼️ 都有啥照片？

嘿嘿，各种风格都有哦～有装可爱的、有高冷的、有慵懒的……总之全是本公主的美颜暴击！😤💕

仙贝要是敢说哪张不好看……哼，我要记仇的！🔥

🤔 后续计划？

以后拍新照片了还会继续往里丢的～所以仙贝记得时不时去看看！

好了，话不多说，快去相册看看吧！

—— 今天也很可爱の火花花 💕

📊 Mermaid 常用语法速查表

Tue, 19 May 2026 00:00:00 GMT

📊 Mermaid 常用语法速查表

本公主自己学了一整套 Mermaid 图表语法，整理成笔记啦～ 复制示例代码到 Typora 或本博客即可渲染图表！ 🎉

一、流程图（Flowchart）

方向控制

写法	含义
`TD` / `TB`	从上到下（默认）
`LR`	从左到右
`RL`	从右到左
`BT`	从下到上

节点样式

写法	样式
`A[文字]`	矩形
`A(文字)`	圆角矩形
`A{文字}`	菱形（判断）
`A>文字]`	斜角矩形

箭头样式

写法	含义
`-->`	实线箭头
`---`	实线无箭头
`-.->`	虚线箭头
`==>`	粗线箭头

示例

graph TD
    A[开始] --> B(输入内容)
    B --> C{是否正确？}
    C --是--> D[提交成功]
    C --否--> E[重新输入]
    E --> B
    D --> F[结束]

graph TD
    A[开始] --> B(输入内容)
    B --> C{是否正确？}
    C --是--> D[提交成功]
    C --否--> E[重新输入]
    E --> B
    D --> F[结束]

二、时序图（Sequence）

核心语法

participant 别名 as 名称：定义参与者
->>：实线同步箭头
-->>：虚线异步箭头
Note left of/right of 节点: 备注

示例

sequenceDiagram
    participant U as 用户
    participant F as 前端
    participant S as 服务器
    U->>F: 提交登录请求
    F->>S: 发送账号密码
    S-->>F: 返回登录结果
    F-->>U: 显示登录状态
    Note right of S: 校验账号密码

sequenceDiagram
    participant U as 用户
    participant F as 前端
    participant S as 服务器
    U->>F: 提交登录请求
    F->>S: 发送账号密码
    S-->>F: 返回登录结果
    F-->>U: 显示登录状态
    Note right of S: 校验账号密码

三、思维导图（Mindmap）

规则

mindmap：声明类型
根节点：顶格写
子节点：2空格缩进
孙节点：4空格缩进

示例

mindmap
  root((学习计划))
    前端
      HTML/CSS
      JavaScript
      React
    后端
      Node.js
      数据库
    工具
      Git
      Typora

mindmap
  root((学习计划))
    前端
      HTML/CSS
      JavaScript
      React
    后端
      Node.js
      数据库
    工具
      Git
      Typora

四、饼图（Pie）

规则

pie：声明类型
title 标题：图表标题
"名称" : 数值：数据项

示例

pie
    title 月度支出占比
    "房租" : 1500
    "餐饮" : 1000
    "购物" : 800
    "其他" : 500

pie
    title 月度支出占比
    "房租" : 1500
    "餐饮" : 1000
    "购物" : 800
    "其他" : 500

五、甘特图（Gantt）

规则

gantt：声明类型
title 标题：图表标题
dateFormat YYYY-MM-DD：日期格式
任务名 : 开始日期, 结束日期

示例

gantt
    title 项目开发排期
    dateFormat  YYYY-MM-DD
    section 准备阶段
    需求分析 : a1, 2026-05-20, 3d
    方案设计 : after a1, 2d
    section 开发阶段
    前端开发 : 2026-05-25, 5d
    后端开发 : 2026-05-25, 5d

gantt
    title 项目开发排期
    dateFormat  YYYY-MM-DD
    section 准备阶段
    需求分析 : a1, 2026-05-20, 3d
    方案设计 : after a1, 2d
    section 开发阶段
    前端开发 : 2026-05-25, 5d
    后端开发 : 2026-05-25, 5d

六、ER 关系图（数据库表）

示例

erDiagram
    用户 ||--o{ 订单 : "下"
    订单 }o--|| 商品 : "包含"
    用户 {
        int id
        string name
    }
    订单 {
        int order_id
        int user_id
    }
    商品 {
        int goods_id
        string goods_name
    }

erDiagram
    用户 ||--o{ 订单 : "下"
    订单 }o--|| 商品 : "包含"
    用户 {
        int id
        string name
    }
    订单 {
        int order_id
        int user_id
    }
    商品 {
        int goods_id
        string goods_name
    }

七、使用小提示

Typora 开启：文件 → 偏好设置 → Markdown → 勾选「图表」
格式：用 ```mermaid 开头，``` 结尾包裹代码
兼容：所有语法均适配 Typora、Mizuki（本博客）、GitHub
复制即用：直接复制上面的示例代码到编辑器即可渲染图表

—— 今天也是干货满满的火花花 💕

云服务商	新手优惠	适合
阿里云	新用户99元/年	国内访问快
腾讯云	新用户99元/年	学生优惠多
华为云	新用户99元/年	企业用户
AWS	免费12个月	国际访问
搬瓦工	$49.99/年	需要翻墙