Shell脚本如何实现屏障同步

wen 实用脚本 2026-07-06 5

Shell脚本如何实现屏障同步：多进程协作的终极指南

目录导读

什么是屏障同步？为什么需要它？
Shell脚本中的多进程挑战
实现屏障同步的5种核心方法
基于命名管道的屏障
基于临时文件的屏障
使用flock文件锁
基于信号量的实现
利用mkfifo与wait的组合
性能对比与最佳实践
常见问题与问答

什么是屏障同步？为什么需要它？

屏障同步（Barrier Synchronization）是一种并行编程中常用的同步机制，它确保所有参与进程或线程在某个“屏障点”上必须全部到达，才能继续向下执行，在Shell脚本中，当你需要多个后台进程完成各自的任务（如并行下载文件、同时处理数据分片），然后在某个节点统一汇总时,屏障同步不可或缺。

Shell脚本如何实现屏障同步

典型场景：

批量数据预处理：10个进程分别处理10个文件,全部完成后执行合并操作。
分布式测试：多个客户端同时发起请求,等待所有客户端就绪后同步开始。
管道通信：多个子进程写入临时文件,主进程等待所有写入完毕再读取。

Shell脚本中的多进程挑战

Shell脚本（Bash）本身不提供原生的屏障同步原语，它更擅长顺序执行或简单的后台&配合wait，但wait只能等待所有子进程结束，无法实现部分进程的阶段性同步。

#!/bin/bash
for i in {1..5}; do
    (sleep $i; echo "进程$i完成") &
done
wait
echo "所有进程完成"

这段代码确实等待所有进程结束，但如果你想让进程在中间某个点同步（比如等待其他进程都打印完第一行后再打印第二行），wait就无能为力了。

核心挑战：Shell缺少线程库，只能通过文件系统、管道、信号等外部机制实现进程间同步。

实现屏障同步的5种核心方法

下面逐一详解5种实战方法,每种均附带完整脚本和解析。

基于命名管道的屏障

原理：利用命名管道（FIFO）的阻塞特性：当管道没有数据时，读取端会阻塞；当写入方达到预定数量后关闭管道,读取方恢复。

#!/bin/bash
barrier_fifo="/tmp/barrier_$$.fifo"
process_count=5
# 创建命名管道
mkfifo "$barrier_fifo"
# 屏障函数
barrier() {
    # 每个进程向管道写入一个字符
    echo > "$barrier_fifo"
    # 等待所有进程写入完毕（读走所有字符）
    read -n $process_count < "$barrier_fifo"
}
# 启动5个子进程
for i in $(seq 1 $process_count); do
    (
        echo "进程$i 开始工作"
        sleep $((RANDOM % 3 + 1))
        echo "进程$i 到达屏障"
        barrier
        echo "进程$i 通过屏障，继续执行"
    ) &
done
wait
rm -f "$barrier_fifo"

工作原理：每个进程在barrier函数中先向管道写入一个字节，然后尝试从管道读取process_count个字节，由于写入操作会阻塞直到有进程读取，而读取需要process_count个字节才返回，因此所有进程会同时在该点等待，直到最后一个进程写入后，读取操作拿到足够数据,所有进程才继续。

注意事项：管道文件需提前创建,且进程数必须与读取字节数匹配。

基于临时文件的屏障

原理：每个进程到达屏障点时，在共享目录下创建一个标记文件,然后循环检查文件总数是否等于进程总数。

#!/bin/bash
barrier_dir="/tmp/barrier_$$"
process_count=5
mkdir -p "$barrier_dir"
barrier() {
    local pid=$1
    # 创建本进程标记
    touch "$barrier_dir/$pid.ready"
    # 轮询等待所有进程标记出现
    while [ $(ls "$barrier_dir"/*.ready 2>/dev/null | wc -l) -lt $process_count ]; do
        sleep 0.1
    done
    # 清理标记（可选）
    # rm "$barrier_dir/$pid.ready"
}
for i in $(seq 1 $process_count); do
    (
        echo "进程$i 准备"
        sleep $((RANDOM % 3 + 1))
        barrier $i
        echo "进程$i 全部就绪，继续"
    ) &
done
wait
rm -rf "$barrier_dir"

优点：简单直观，无需特殊系统调用。缺点：轮询消耗CPU,当进程数大时目录操作可能成为瓶颈。

优化：使用inotifywait监听文件创建事件可避免轮询（需安装inotify-tools）。

使用flock文件锁

原理：利用flock（文件锁）实现一个计数锁：每个进程获取锁后递增计数器,当计数器达到目标值后广播解锁。

#!/bin/bash
lock_file="/tmp/barrier_lock_$$"
counter_file="/tmp/barrier_counter_$$"
process_count=5
echo 0 > "$counter_file"
barrier() {
    local id=$1
    exec 200>"$lock_file"
    flock -x 200
    local count=$(cat "$counter_file")
    count=$((count + 1))
    echo $count > "$counter_file"
    flock -u 200
    # 如果达到总数，等待0.5秒让最后一个进程也解锁（简单实现）
    if [ $count -eq $process_count ]; then
        sleep 0.2
    fi
    # 再次加锁读取计数器，但这里只需通过轮询等待计数到目标值
    while true; do
        flock -x 200
        local current=$(cat "$counter_file")
        flock -u 200
        if [ $current -eq $process_count ]; then
            break
        fi
        sleep 0.1
    done
}
for i in $(seq 1 $process_count); do
    (
        echo "进程$i 运行中"
        sleep $((RANDOM % 3 + 1))
        barrier $i
        echo "进程$i 通过屏障"
    ) &
done
wait
rm -f "$lock_file" "$counter_file"

说明：这种实现本质上仍是轮询，且锁的竞争可能影响性能，但flock机制本身是原子且安全的,适合需要精确控制的场景。

基于信号量的实现

原理：通过文件系统模拟信号量：使用一个文件记录当前信号量值，每个进程到达时递减信号量,当信号量为0时唤醒。

#!/bin/bash
sem_file="/tmp/barrier_sem_$$"
sem_count=$1  # 需要同步的进程数，例如5
# 初始化信号量
echo $sem_count > "$sem_file"
barrier() {
    # 原子递减
    while true; do
        local val=$(cat "$sem_file")
        if [ $val -gt 0 ]; then
            # 尝试写回新值（存在竞态，建议用flock保护）
            # 简化版：使用flock保护
            exec 200>"$sem_file"
            flock -x 200
            val=$(cat "$sem_file")
            if [ $val -gt 0 ]; then
                echo $((val - 1)) > "$sem_file"
                flock -u 200
                break
            fi
            flock -u 200
        fi
        sleep 0.1
    done
    # 等待信号量归零
    while [ $(cat "$sem_file") -ne 0 ]; do
        sleep 0.1
    done
}

注意：受限于文件I/O的原子性，纯Shell实现信号量较为复杂，通常不建议投入生产,但可作为教学示例。

利用mkfifo与wait的组合（推荐）

这是对方法一的改进，使用多个管道，避免单个管道的读/写语义歧义。

#!/bin/bash
process_count=5
pipe_dir="/tmp/barrier_pipes_$$"
mkdir -p "$pipe_dir"
for i in $(seq 1 $process_count); do
    mkfifo "$pipe_dir/$i"
done
barrier() {
    local pid=$1
    # 写入自己的管道
    echo "ready" > "$pipe_dir/$pid" &
    # 读取所有其他管道的就绪信号
    for j in $(seq 1 $process_count); do
        if [ $j -ne $pid ]; then
            read line < "$pipe_dir/$j"
        fi
    done
}
for i in $(seq 1 $process_count); do
    (
        echo "进程$i 开始"
        sleep $((RANDOM % 3 + 1))
        barrier $i
        echo "进程$i 同步完成"
    ) &
done
wait
rm -rf "$pipe_dir"

核心逻辑：每个进程有一个专属命名管道，到达屏障时，向自己的管道写入“ready”，然后从其他所有进程的管道读取，因为读操作会阻塞，所以直到所有进程都写入后，读取才完成,实现同步。

优点：无轮询，纯阻塞式，资源消耗低。缺点：创建多个管道,进程数大时开销增加。

性能对比与最佳实践

方法	阻塞/轮询	资源消耗	可靠性	适用场景
命名管道（单）	阻塞	低	中	小规模并行，进程数固定
临时文件+轮询	轮询	高CPU	高	对性能不敏感的场景
flock计数器	混合	中	高	需要精确计数
信号量模拟	复杂	高	低	教学演示
多管道+阻塞读	阻塞	中	高	推荐：中等规模，可靠性高