本文系统梳理 Linux Shell 中 head/tail 命令、父子进程模型、变量隔离与 export、管道底层原理四个核心知识点，并通过实验数据与图解帮助建立清晰的认知模型。

---

一、head 与 tail：精准截取文件内容

基本用法

head -N file    # 取文件前 N 行
tail -N file    # 取文件后 N 行

示例：

head -3 test.txt    # 输出第 1~3 行
tail -2 test.txt    # 输出倒数第 1~2 行

管道组合：精确取任意一行

单独的 head 和 tail 只能取头部或尾部，但两者通过管道 | 组合后，可以精确定位到任意一行。

head -8 test.txt | tail -1

执行逻辑：

1. head -8 test.txt 先输出文件的前 8 行
2. 再用 tail -1 从这 8 行中取最后 1 行
3. 最终结果就是原文件的第 8 行

通用公式：取第 N 行

head -N file | tail -1

这个技巧在日志分析、数据处理脚本中非常常用。

---

二、Linux 父子进程模型

进程树

Linux 中所有进程都以树状结构组织，根节点是 init（PID=1）。可以用 pstree 命令直观查看：

pstree

输出示例：

init─┬─auditd───{auditd}
     ├─crond
     ├─sshd─┬─2*[sshd───bash]
     │       └─sshd───bash───bash───pstree
     └─...

可以看到：用户通过 SSH 登录后，sshd 派生出 bash，我们执行命令时又从 bash 派生子进程。

查看父子关系

echo $$        # 显示当前 bash 的 PID（如 4398）
/bin/bash      # 手动启动一个子 bash
echo $$        # 此时显示子进程 PID（如 4463）

ps -fe | grep 4398
# 可看到：4463 的 PPID（父进程ID）正是 4398

用 exit 退出子 bash 后，$$ 重新变回 4398——说明回到了父进程。

核心规律

每执行一个命令，shell 都会 fork() 出一个子进程来运行它。子进程结束后，控制权回到父进程。

---

三、变量隔离与 export

问题的来源

父进程中定义的变量，子进程默认看不到。这是 Linux 进程隔离的体现：

x=100
echo $x        # 父进程：100

/bin/bash      # 进入子进程
echo $x        # 子进程：空（什么都没有）
exit

子进程的修改不会影响父进程

a=1
echo $a        # 输出：1

{ a=9; echo "sdfsdf"; } | cat
# 在管道子进程中把 a 改为 9

echo $a        # 输出：1（父进程的 a 没有变）

这证明了进程之间的变量是完全隔离的，子进程的修改不会反向传播到父进程。

export：打破隔离的方式

export 把变量标记为环境变量。子进程在 fork 时会自动继承父进程的环境变量：

x=100
export x        # 导出为环境变量

/bin/bash       # 进入子进程
echo $x         # 输出：100（可以看到了！）
echo $$         # 显示子进程 PID，如 4481

实际应用：Java 等环境变量配置

这正是为什么在 /etc/profile 中要用 export 来配置 Java、Hadoop 等环境变量：

export JAVA_HOME=/usr/java/default
export HADOOP_HOME=/opt/bigdata/hadoop-2.6.5
export HIVE_HOME=/opt/bigdata/hive-2.3.4
export PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbin

如果不加 export，这些变量只存在于当前 shell，启动 Java 应用的子进程就找不到 JAVA_HOME，导致命令找不到或路径错误。

---

四、进阶：$$ 与 $BASHPID 的区别

这是一个非常容易混淆的细节，理解它需要知道 bash 的命令解析时机。

实验现象

echo $$                   # 输出：4398（当前 bash PID）

echo $$ | cat             # 输出：4398（仍是父进程 PID！）
echo $BASHPID | cat       # 输出：4496（子进程真实 PID）

为什么 echo $$ | cat 明明在管道子进程中执行，却输出的是父进程 PID？

根本原因：$$ 的展开时机

变量	展开时机	含义
$$	命令解析阶段（fork 之前）	shell 在分析命令行时就把它替换成当前 PID，此时子进程还没创建
$BASHPID	运行时（fork 之后）	每次读取时动态获取当前进程的真实 PID

执行 echo $$ | cat 的完整流程：

1. bash（PID=4398）解析整行命令
2. 解析阶段：$$ 被替换为 4398，命令变成 echo 4398 | cat
3. 执行阶段：bash fork 出两个子进程来执行管道两端
4. 子进程执行的实际上是 echo 4398，所以输出 4398

而 $BASHPID 不在解析阶段展开，它在子进程运行时才读取，所以返回的是子进程自己的 PID（4496）。

验证管道确实启动了新进程

{ echo $BASHPID; read x; } | { cat; echo $BASHPID; read y; }
# 左侧输出：4512
# 右侧输出：4513

左右两侧 PID 不同，且都不是父进程 4398，证明管道两端各自 fork 了一个独立的子进程。

---

五、管道底层原理：文件描述符视角

什么是文件描述符（FD）

Linux 一切皆文件。每个进程打开的文件（包括终端、网络连接、管道）都用一个整数编号来标识，这就是文件描述符（File Descriptor, FD）。

默认情况下每个进程有三个标准 FD：

FD	名称	默认指向
0	stdin（标准输入）	终端键盘
1	stdout（标准输出）	终端屏幕
2	stderr（标准错误）	终端屏幕

管道做了什么

执行 { echo $BASHPID; read x; } | { cat; echo $BASHPID; read y; } 时：

父进程（PID=4398）在内核中创建一个 FIFO 管道（编号 pipe:[39968]），然后 fork 两个子进程：

子进程 4512（写端）：

FD 0  ← /dev/pts/2    （stdin，从终端读）
FD 1  → pipe:[39968]  （stdout，写入管道）  ← 关键：被重定向到管道写端
FD 2  → /dev/pts/2    （stderr，输出到终端）
FD 8  → socket:[39172]（bash 内部网络连接）
FD255 → /dev/pts/2    （bash 内部使用）

子进程 4513（读端）：

FD 0  ← pipe:[39968]  （stdin，从管道读）  ← 关键：被重定向到管道读端
FD 1  → /dev/pts/2    （stdout，输出到终端）
FD 2  → /dev/pts/2    （stderr，输出到终端）
FD 8  → socket:[39172]
FD255 → /dev/pts/2

数据流向

4512 执行写操作 → FD1(stdout) → pipe:[39968] → FD0(stdin) → 4513 读取

4512 的 FD1（原本指向终端屏幕）被重定向到管道写端；4513 的 FD0（原本指向终端键盘）被重定向到管道读端。 两个进程通过这个内核 FIFO 缓冲区交换数据，互不干扰。

用命令验证

# 查看进程 4512 的文件描述符
cd /proc/4512/fd && ll
# FD1 → pipe:[39968]   l-wx（只写）

cd /proc/4513/fd && ll
# FD0 → pipe:[39968]   lr-x（只读）

# 用 lsof 查看更详细信息
lsof -op 4512
# bash  4512  root  1w  FIFO  0,8  0t0  39968 pipe

1w 中的 w 表示写，0r 中的 r 表示读，与预期完全一致。

---

总结

知识点	核心命令	关键结论
head/tail	head -N file | tail -1	组合使用可精确取任意行
父子进程	pstree、ps -fe	所有进程树状组织，init 是根
变量隔离	export VAR	普通变量子进程不继承，export 后可继承，子进程修改不影响父进程
$$ vs $BASHPID	echo $BASHPID | cat	$$ 解析期展开（父PID），$BASHPID 运行时读取（子PID）
管道底层	/proc/PID/fd、lsof	管道 = 两个子进程 + 一个内核FIFO，通过FD重定向实现数据流转

一句话理解管道的本质：
A | B 不是 A 的输出"传给" B，而是内核创建一个 FIFO，把 A 的 stdout 接到 FIFO 的写端，把 B 的 stdin 接到 FIFO 的读端，A 和 B 是并行运行的两个独立子进程。