Shell 脚本的“并行宇宙”：并发与进程控制的艺术

引言：从单线程到多任务的飞跃

想象一下你正在经营一家餐厅：

单线程模式：你一个人又要接单、又要做菜、又要上菜。你必须做完第一道菜，才能开始做第二道。这就是大多数脚本默认的顺序执行。
并发模式：你雇佣了几个厨师。你负责接单（主进程），然后将不同的菜谱分配给不同的厨师（子进程），让他们同时开始烹饪。最后，你等待所有厨师完成后一起上菜。这就是并发。

在 Shell 脚本的世界里，我们同样可以告别“单线程”的缓慢，通过强大的进程控制功能，实现任务的并行化，极大提升脚本的执行效率。无论是需要处理成百上千个文件，还是同时检查多台服务器的状态，并发编程都能让你的脚本速度提升一个数量级。

本文将带你深入探索 Shell 中的并发执行、进程控制和作业管理，让你掌握如何指挥一个“进程军团”，而不是当一个“光杆司令”。

一、基础入门：后台运行与作业控制

Shell 提供了内置的命令来管理多个进程，这些进程在 Shell 的上下文中被称为“作业（Jobs）”。

1.1 将命令放入后台（`&`）

最简单的并发方式就是在命令末尾加上一个 & 符号。这会让该命令在后台子进程中立即开始运行，而主脚本可以继续向下执行。

#!/bin/bash

echo "开始准备晚餐..."

# 启动三个“厨师”在后台同时工作
煮米饭 &
炒菜 &
炖汤 &

echo "所有任务都已分配，我可以去摆餐具了..."
# 脚本会立即执行到这行，而不会等待上面的命令完成

1.2 查看和管理作业（`jobs`）

你怎么知道你的“厨师”们干得怎么样了？使用 jobs 命令。

#!/bin/bash

煮米饭 &
炒菜 &
炖汤 &

# 查看当前后台作业列表及其状态
jobs -l
# 输出示例：
# [1]   12345 Running                 煮米饭 &
# [2]   12346 Running                 炒菜 &
# [3]   12347 Running                 炖汤 &

# 等待某个特定作业完成（使用 %n，n 是作业编号）
wait %1 # 等待“煮米饭”这个作业完成
echo "米饭已经好了！"

# 将后台作业拉回前台（常用于需要交互的任务）
fg %2 # 将“炒菜”拉回前台，这样我们可以随时控制它

# 将前台任务再次暂停并放入后台（先按 Ctrl+Z，然后）
bg %3 # 让暂停的“炖汤”作业在后台继续运行

二、核心技能：等待与收集结果（`wait` 命令）

启动后台任务很简单，但更重要的是如何协调它们。wait 命令是我们的总指挥棒。

2.1 等待所有后台任务完成

最简单的用法是等待所有后台作业完成后再继续。

#!/bin/bash

echo "开始并行下载..."

download_file1.sh &
download_file2.sh &
download_file3.sh &

# 等待所有后台作业完成
wait

echo "所有下载任务已完成！"

2.2 等待特定进程完成（通过 PID）

更精细的控制是获取后台进程的 PID（进程ID），并等待特定的 PID。

#!/bin/bash

download_file1.sh &
pid1=$!  # $! 是一个特殊变量，表示上一个后台进程的PID

download_file2.sh &
pid2=$!

download_file3.sh &
pid3=$!

# 现在我们可以有选择地等待
wait $pid1
echo "文件1 下载完成！"

wait $pid2
echo "文件2 下载完成！"

# 不再等待 $pid3，主脚本可以直接退出

三、高级并发模式：进程池与并发控制

无节制地启动成千上万个后台进程会拖垮系统。我们需要一个“进程池”来限制并发数量。

3.1 使用命名管道（FIFO）实现并发控制

这是最经典、最纯正的 Shell 并发控制方法，它创建一个令牌桶，只有拿到令牌的任务才能开始。

#!/bin/bash

# 设置最大并发数
MAX_CONCURRENT=3

# 创建一个命名管道（FIFO）作为“令牌桶”
FIFO_FILE="/tmp/$$.fifo" # 使用当前脚本的PID作为文件名，避免冲突
mkfifo $FIFO_FILE
# 将文件描述符 3 与FIFO绑定
exec 3<>$FIFO_FILE
rm -f $FIFO_FILE # 删除文件系统上的引用，但文件描述符仍存在

# 向令牌桶中预先放入令牌
for ((i=0; i<MAX_CONCURRENT; i++)); do
    echo >&3
done

echo "开始处理任务，最大并发数: $MAX_CONCURRENT"

# 假设有一个任务列表
TASK_LIST=(task1.task task2.task ... task100.task)

# 函数：实际执行的任务
run_task() {
    local task_name=$1
    echo "[$(date)] 开始任务: $task_name"
    sleep 2 # 模拟任务执行时间
    echo "[$(date)] 完成任务: $task_name"
}

# 遍历所有任务
for task in "${TASK_LIST[@]}"; do
    read -u 3 # 从文件描述符3中读取一个令牌（如果无令牌，则阻塞等待）
    {
        # 在子shell中执行任务
        run_task "$task"
        echo >&3 # 任务完成后，归还令牌
    } & # 将整个子shell放入后台执行
done

# 等待所有后台任务完成
wait

# 关闭文件描述符
exec 3>&-

echo "所有任务处理完毕！"

3.2 更现代的并发方式：`xargs` 与 `GNU parallel`

对于许多日常任务，我们不必“重复造轮子”。

使用 xargs 的 -P 参数：

# 查找所有 .log 文件并用 gzip 压缩，最多同时运行 4 个进程
find . -name "*.log" -print0 | xargs -0 -P 4 -n 1 gzip

# -print0 和 -0: 处理包含空格的文件名
# -P 4: 最大并发进程数
# -n 1: 每次只传递一个参数给命令

使用功能强大的 GNU parallel：
（可能需要安装：sudo apt-get install parallel 或 brew install parallel）

# 基本用法：并行压缩文件
parallel -j 4 gzip ::: *.log

# 从文件中读取任务列表
cat list_of_urls.txt | parallel -j 5 wget {}

# 并行处理，并将输出按顺序保存到文件
seq 100 | parallel -j 8 --joblog job.log "echo Processing {}; sleep 2" > output.log

四、实战案例：高效的服务器状态检查

让我们编写一个脚本，同时检查多台服务器的 SSH 端口是否开放，并控制并发数量。

#!/bin/bash

# 服务器列表
SERVERS=(
    "web1.example.com"
    "web2.example.com"
    "db1.example.com"
    "db2.example.com"
    "cache1.example.com"
    "app1.example.com"
    "app2.example.com"
)

# 最大并发检查数
MAX_CONCURRENT=3

# 创建进程池
temp_fifo=$(mktemp -u)
mkfifo "$temp_fifo"
exec 3<>"$temp_fifo"
rm -f "$temp_fifo"

for ((i=0; i<MAX_CONCURRENT; i++)); do
    echo >&3
done

# 检查函数
check_server() {
    local server=$1
    # 使用 nc 检查端口 22 (SSH) 是否开放，设置2秒超时
    if nc -z -w 2 "$server" 22 &>/dev/null; then
        echo "[OK] $server: SSH 端口开放"
        return 0
    else
        echo "[FAIL] $server: SSH 端口无法访问"
        return 1
    fi
}

echo "开始检查 ${#SERVERS[@]} 台服务器的状态..."
echo "=========================================="

# 并发检查
for server in "${SERVERS[@]}"; do
    read -u 3
    {
        check_server "$server"
        echo >&3
    } &
done

wait # 等待所有检查完成

exec 3>&- # 关闭文件描述符

echo "=========================================="
echo "所有服务器检查完成！"

五、陷阱与最佳实践

避免竞态条件（Race Conditions）：多个进程同时读写同一个文件时，使用文件锁（flock）来避免数据损坏。

(
  flock -x 200 # 获取独占锁
  # 在这里安全地读写共享文件
  echo "新内容" >> shared_file.log
) 200>/tmp/shared_file.lock

处理子进程的输出：大量后台进程同时输出到 stdout 会混成一团乱麻。建议：
- 重定向到文件：command > output.log 2>&1 &
- 使用 logger 命令输出到系统日志
- 每个进程输出到单独的文件
信号传播：默认情况下，Ctrl+C (SIGINT) 只会中断主脚本，不会中断后台进程。你需要手动处理：
trap 'kill $(jobs -p)' EXIT # 脚本退出时，杀死所有后台作业
不要过度并发：并发数不是越多越好。通常设置为 CPU 核心数的 1-2 倍是最有效的。
考虑使用更专业的工具：对于极其复杂的并行任务，考虑使用 GNU parallel、make -j、ansible 或者直接用 Python 的 multiprocessing 模块。