shell如何并发执行

Posted on Edited on Views:

情景

shell脚本的执行效率虽高，但当任务量巨大时仍然需要较长的时间，尤其是需要执行一大批的命令时。因为默认情况下，shell脚本中的命令是串行执行的。如果这些命令相互之间是独立的，则可以使用“并发”的方式执行这些命令，这样可以更好地利用系统资源，提升运行效率，缩短脚本执行的时间。如果命令相互之间存在交互，则情况就复杂了，那么不建议使用shell脚本来完成多线程的实现。

为了方便阐述，使用一段测试代码。在这段代码中，通过seq命令输出1到10，使用for…in语句产生一个执行10次的循环。每一次循环都执行sleep 1，并echo出当前循环对应的数字。

注意：
真实的使用场景下，循环次数不一定等于10，或高或低，具体取决于实际的需求。
真实的使用场景下，循环体内执行的语句往往比较耗费系统资源，或比较耗时等。
请根据真实场景的各种情况理解本文想要表达的内容。

cat test1.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#/bin/bash

all_num=10

a=$(date +%H%M%S)

for num in `seq 1 ${all_num}`
do
	sleep 1
	echo ${num}
done

b=$(date +%H%M%S)

echo -e "startTime:\t$a"
echo -e "endTime:\t$b"

通过上述代码可知，为了体现执行的时间，将循环体开始前后的时间打印了出来。

运行结果：

$ sh test1.sh

startTime: 193649
endTime: 193659

10次循环，每次sleep 1秒，所以总执行时间10s。

方案1：使用”&”使命令后台运行

在linux中，在命令的末尾加上&符号，则表示该命令将在后台执行，这样后面的命令不用等待前面的命令执行完就可以开始执行了。示例中的循环体内有多条命令，则可以以{}括起来，在大括号后面添加&符号。

cat test2.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#/bin/bash

all_num=10

a=$(date +%H%M%S)

for num in `seq 1 ${all_num}`
do
{
	sleep 1
	echo ${num}
} &
done

b=$(date +%H%M%S)

echo -e "startTime:\t$a"
echo -e "endTime:\t$b"

运行结果：

sh test2.sh
startTime: 194147
endTime: 194147

因为循环体内的命令全部进入后台，所以均在sleep了1秒以后输出了数字。开始和结束时间相同，即循环体的执行时间不到1秒钟，这是由于循环体在后台执行，没有占用脚本主进程的时间。

方案2：命令后台运行+wait命令

解决上面的问题，只需要在上述循环体的done语句后面加上wait命令，该命令等待当前脚本进程下的子进程结束，再运行后面的语句。

$ cat test3.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#/bin/bash

all_num=10

a=$(date +%H%M%S)

for num in `seq 1 ${all_num}`
do
{
	sleep 1
	echo ${num}
} &
done

# 等待后台任务执行完毕，在继续
wait

b=$(date +%H%M%S)

echo -e "startTime:\t$a"
echo -e "endTime:\t$b"

运行结果：
$ sh test3.sh
startTime: 194221
endTime: 194222

但这样依然存在一个问题：
因为&使得所有循环体内的命令全部进入后台运行，那么倘若循环的次数很多，会使操作系统在瞬间创建出所有的子进程，这会非常消耗系统的资源。如果循环体内的命令又很消耗系统资源，则结果可想而知。

最好的方法是并发的进程是可配置的。

方案3：使用文件描述符控制并发数

$ cat test4.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#/bin/bash

all_num=10
# 设置并发的进程数
thread_num=5

a=$(date +%H%M%S)

# mkfifo 创建命名管道
tempfifo="my_temp_fifo"
mkfifo ${tempfifo}

#关联fifo文件和fd6，使文件描述符为非阻塞式
exec 6<>${tempfifo}
rm -f ${tempfifo}

# 为文件描述符创建占位信息
for ((i=1;i<=${thread_num};i++))
do
{
	echo 
}
done >&6 


# 
for num in `seq 1 ${all_num}`
do
{
	read -u6   ##read -u6命令执行一次，相当于尝试从fd6中获取一行，如果获取不到，则阻塞获取到了           
               ##一行后，fd6就少了一行了，开始处理子进程，子进程放在后台执行
	{
		sleep 1
		echo ${num}
		echo "" >&6   #完成后再补充一个空值到fd6中，释放一个锁
	} & 
} 
done 

wait

# 关闭fd6管道
exec 6>&-

b=$(date +%H%M%S)

echo -e "startTime:\t$a"
echo -e "endTime:\t$b"

运行结果：
$ sh test4.sh
startTime: 195227
endTime: 195229

方案4：使用xargs -P控制并发数

xargs命令有一个-P参数，表示支持的最大进程数，默认为1。为0时表示尽可能地大，即方案2的效果。

$ cat test5.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
#/bin/bash

all_num=10
thread_num=5

a=$(date +%H%M%S)

seq 1 ${all_num} | xargs -n 1 -I {} -P ${thread_num} sh -c "sleep 1;echo {}"

b=$(date +%H%M%S)

echo -e "startTime:\t$a"
echo -e "endTime:\t$b"

运行结果：
$ sh test5.sh
startTime: 195257
endTime: 195259

方案5：使用GNU parallel命令控制并发数

GNU parallel命令是非常强大的并行计算命令，使用-j参数控制其并发数量。

$ cat test6.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#/bin/bash

all_num=10
thread_num=6

a=$(date +%H%M%S)


parallel -j 5 "sleep 1;echo {}" ::: `seq 1 10`

b=$(date +%H%M%S)

echo -e "startTime:\t$a"
echo -e "endTime:\t$b"

运行结果：
$ sh test6.sh
1
2
3
4
5
6
7
8
9
10
startTime: 195616
endTime: 195618

总结

“多线程”的好处不言而喻，虽然shell中并没有真正的多线程，但上述解决方案可以实现“多线程”的效果，重要的是，在实际编写脚本时应有这样的考虑和实现。