Shell脚本如何实现协程并发

wen 实用脚本 2026-07-08 2

Shell脚本如何实现协程并发：实战指南与性能优化

目录导读

协程并发基础概念
Shell中实现协程的核心方法
经典实现：使用&与wait构建协程池
进阶技巧：命名管道实现协程通信
实战案例：并发文件下载与数据汇总
性能对比：协程vs子进程vs线程
常见问题与问答

协程并发基础概念

什么是协程？
协程（Coroutine）是一种用户态的轻量级线程，由程序自身控制调度，而非操作系统内核，在Shell脚本的语境下，“协程并发”通常指通过后台进程（Background Job）与信号控制逻辑，模拟协程的协作式调度行为。

Shell脚本如何实现协程并发

与线程相比,协程的开销极小（无需内核上下文切换），在I/O密集型场景（如网络请求、文件读写）中尤为高效，Bash虽然不原生支持协程语法，但通过“管道+进程组”或“coproc”命令，完全可以实现符合协程理念的并发模型。

核心设计原则：

非抢占式：协程主动让出控制权（通过wait或信号）
轻量级：每个协程对应一个子Shell进程（而非线程）
通信优雅：利用文件描述符或命名管道进行数据交换

Shell中实现协程的核心方法

1 原生方法：`coproc`命令（Bash 4.0+）

coproc MYCORO {
    while read input; do
        echo "协程收到: $input"
    done
}
echo "hello" >&${MYCORO[1]}  # 向协程写数据
read output <&${MYCORO[0]}   # 读取协程输出

coproc创建了一个双向管道，与子Shell建立的通信类似系统调用的pipe()。

2 经典方法：后台进程+`wait`控制

job() {
    local id=$1
    sleep $((RANDOM % 5))
    echo "任务$id完成"
}
for i in {1..5}; do job $i & done  # 启动5个“协程”
wait  # 等待全部完成

此方法虽简单,但无法精确控制并发数量（N个后台进程即N个并发）。

3 进阶方法：命名管道（FIFO）做协程池

# 创建命名管道
mkfifo coqueue
# 工作协程
worker() {
    while read task; do
        echo "处理任务: $task"
    done < coqueue
}
# 启动3个工作协程
for i in {1..3}; do worker & done
# 分配任务
echo "task1" > coqueue
echo "task2" > coqueue
echo "task3" > coqueue

这种模式实现了真正的协程池：多个协程从共享队列取任务，避免了频繁创建销毁进程的开销。

经典实现：使用`&`与`wait`构建协程池

1 限流并发：令牌环控制

concurrency_limit=4
task_list=($(seq 1 20))  # 20个任务
running=0
for task in "${task_list[@]}"; do
    {
        echo "开始任务 $task"
        sleep 1  # 模拟计算
        echo "完成 $task"
        echo "DONE" >&3  # 通知主进程
    } &
    running=$((running + 1))
    if [ $running -ge $concurrency_limit ]; then
        read -r -u 3  # 等待一个“DONE”信号
        running=$((running - 1))
    fi
done
wait
exec 3<&-  # 关闭额外文件描述符

工作原理：

每启动一个后台进程,计数器running增加
当达到4个并发时,通过文件描述符3阻塞，直到一个协程完成并写入“DONE”
这比简单的wait更高效，因为不需要等待所有协程结束才能继续

2 错误处理扩展

trap 'kill 0; exit 1' INT TERM
# 如果任一协程失败，立即终止所有
worker() {
    if ! some_command; then
        echo "FAIL" >&4
        kill $$
    fi
}

进阶技巧：命名管道实现协程通信

1 生产者-消费者模型

#!/bin/bash
PIPE=/tmp/coroutine_pipe
mkfifo $PIPE
# 消费者协程
consumer() {
    while true; do
        if read line < $PIPE; then
            echo "消费者处理：$line"
        fi
    done
}
# 生产者协程
producer() {
    for i in {1..10}; do
        echo "数据包$i" > $PIPE
        sleep 0.5
    done
    echo "EXIT" > $PIPE  # 终止信号
}
consumer &
producer &
wait
rm -f $PIPE

优势：

解耦生产与消费速度
协程间不需要共享变量
天然支持广播（多个消费者读取同一管道）

2 双向通信示例

# 协程1：数据计算
coproc CALC {
    while read a b; do
        echo $((a + b))
    done
}
# 协程2：数据处理
echo "3 5" >&${CALC[1]}
read result <&${CALC[0]}
echo "计算结果: $result"  # 输出8

实战案例：并发文件下载与数据汇总

场景：从多个URL下载JSON数据，并汇总为一个CSV文件。

#!/bin/bash
# 协程并发下载器
URLS=(
    "https://api.example.com/data1"
    "https://api.example.com/data2"
    "https://api.example.com/data3"
)
OUTPUT_DIR="/tmp/downloads"
mkdir -p $OUTPUT_DIR
RESULT_FILE="merged.csv"
# 工作协程
download_and_transform() {
    local url=$1
    local id=$2
    local file="${OUTPUT_DIR}/data_${id}.json"
    curl -s -o "$file" "$url"
    if [ $? -eq 0 ]; then
        # 转换JSON为CSV（假设jq可用）
        echo "$(basename $file),$(date +%s)" >> $RESULT_FILE
    else
        echo "ERROR:$id" >> $RESULT_FILE
    fi
}
# 并发启动
COUNTER=0
for url in "${URLS[@]}"; do
    download_and_transform "$url" "$COUNTER" &
    COUNTER=$((COUNTER + 1))
done
wait
# 汇总检查
echo "完成！下载文件数：$(ls $OUTPUT_DIR | wc -l)"

性能对比：

串行执行3个下载：约需4.5秒（假设每次1.5秒）
协程并发3个下载：约需1.5秒（I/O重叠）
效率提升约67%

性能对比：协程vs子进程vs线程

特性	Shell协程（后台进程）	Python多线程	C语言原生协程
上下文切换开销	低（fork/wait）	中（GIL限制）	极低（用户态）
进程/线程数量上限	数千（Linux）	数百（受内存限制）	数万
资源共享	仅文件描述符	全局变量（加锁）	内存直接共享
适用场景	I/O并发，简单任务	I/O并发，CPU密集不优	极高性能场景
实现复杂度	低	中	高

关键结论：

对于Shell脚本,协程（后台进程）是性价比最高的并发方案，尤其适合网络请求、文件操作等I/O任务
如果任务需要大量CPU计算,建议改用Python/Go等语言

常见问题与问答

Q1: Shell协程间如何共享数据？

A: 推荐三种方式：

临时文件：协程写入共享目录文件，主进程读取汇总
命名管道：mkfifo创建管道，协程写入，其他协程或主进程读取
文件描述符：通过coproc生成的管道进行双向通信

Q2: 协程数量过多会导致性能下降吗？

A: 会，每个后台进程占用一个PID和少量内存，当超过系统最大进程数（/etc/security/limits.conf中的nproc）时，会产生资源耗尽错误，建议：

使用令牌桶控制并发数（如最大20）
使用ulimit -u检查当前限制

Q3: 如何优雅终止所有协程？

A: 使用trap捕获退出信号：

cleanup() {
    kill 0  # 终止进程组所有成员
    rm -f /tmp/pipe
}
trap cleanup EXIT

Q4: Shell协程能替代Python的asyncio吗？

A: 不能，Shell协程的本质是进程级并发，而非真正的协作式多任务，如果你需要：

大量（>1000）并发任务
细粒度的事件循环
复杂的异步I/O调度
请使用Python的asyncio、Go的goroutine或Node.js的事件循环。

通过本文的深入分析,我们发现Shell脚本完全有能力实现高效的协程并发，尤其适合运维自动化场景中的I/O密集型任务，掌握coproc、命名管道和进程池控制技巧后，你可以在不引入额外编程语言的情况下，将脚本执行效率提升数倍。

实践建议：从简单的&+wait开始，逐步过渡到带限流的命名管道模式，最后结合trap实现健壮的错误恢复，记住一点——Shell协程的核心哲学是“用最少的资源完成最多的I/O等待”。

（全文完）

Shell脚本如何实现协程并发