按照shell语法，后一个前台命令必须等待前一个前台命令执行完毕才能进行，这就是所谓的单线程程序。如果两条命令之间有依赖性还好，否则后一条命令就白白浪费了等待的时间了。
网上查了一遍，shell并没有真正意义上的多进程。而最简单的节省时间，达到“多线程”效果的办法，是将前台命令变成后台进程，这样一来就可以跳过前台命令的限制了。
引用网上例子：
实例一：全前台进程：
#!/bin/bash
#filename:simple.sh
starttime=$(date +%s)
for ((i=0;i<5;i++));do
{
sleep 3;echo 1>>aa && endtime=$(date +%s) && echo "我是$i,运行了3秒,整个脚本执行了$(expr $endtime - $starttime)秒"
}
done
cat aa|wc -l
rm aa
运行测试：
# time sh simple.sh
我是0,运行了3秒,整个脚本执行了3秒
我是1,运行了3秒,整个脚本执行了6秒
我是2,运行了3秒,整个脚本执行了9秒
我是3,运行了3秒,整个脚本执行了12秒
我是4,运行了3秒,整个脚本执行了15秒
12
real 0m15.131s
user 0m0.046s
sys 0m0.079s
”我是X,运行了3秒“就规规矩矩的顺序输出了。
实例二：使用’&’+wait 实现“多进程”实现
#!/bin/bash
#filename:multithreading.sh
starttime=$(date +%s)
for ((i=0;i<5;i++));do
{
sleep 3;echo 1>>aa && endtime=$(date +%s) && echo "我是$i,运行了3秒,整个脚本执行了$(expr $endtime - $starttime)秒"
}&
done
wait
cat aa|wc -l
rm aa
运行测试：
# time sh multithreading.sh
我是2,运行了3秒,整个脚本执行了3秒
我是3,运行了3秒,整个脚本执行了3秒
我是1,运行了3秒,整个脚本执行了3秒
我是4,运行了3秒,整个脚本执行了3秒
我是0,运行了3秒,整个脚本执行了3秒
5
real 0m3.105s
user 0m0.065s
sys 0m0.115s
运行很快，而且很不老实(顺序都乱了,大概是因为expr运算所花时间不同)
解析：这一个脚本的变化是在命令后面增加了&标记，意思是将进程扔到后台。在shell中，后台命令之间是不区分先来后到关系的。所以各后台子进程会抢夺资源进行运算。
wait命令：
wait [n]
n 表示当前shell中某个执行的后台命令的pid，wait命令会等待该后台进程执行完毕才允许下一个shell语句执行；如果没指定则代表当前shell后台执行的语句，wait会等待到所有的后台程序执行完毕为止。
如果没有wait，后面的shell语句是不会等待后台进程的，一些对前面后台进程有依赖关系的命令执行就不正确了。例如wc命令就会提示aa不存在。
实例三：可控制后台进程数量的“多进程”shell
前一个shell也虽然达到“多进程”执行效果，但是并发执行的子进程数量却是不受控制的。
想想看，如果某一个作业需要执行1万次，那么到底是单进程实现还是像实例1那样多进程实现呢？前者，你慢慢等待吧；后者，祝你好运，希望你的计算机同时执行那么多进程不宕机，不卡死。
而实例3则可以实现可控制进程数量的多线程。
#!/bin/sh
function a_sub {
sleep 3;
echo 1>>aa && endtime=$(date +%s) && echo "我是$i,运行了3秒,整个脚本执行
了$(expr $endtime - $starttime)秒" && echo
}
starttime=$(date +%s)
export starttime
tmp_fifofile="/tmp/$.fifo"
echo $tmp_fifofile
mkfifo $tmp_fifofile
exec 6<>$tmp_fifofile
rm $tmp_fifofile
thread=3
for ((i=0;i
do
echo
done >&6
for ((i=0;i<10;i++))
do
read -u6
{
a_sub || {echo "a_sub is failed"}
echo >&6
} &
done
wait
exec 6>&-
wc -l aa
rm -f aa
exit 0
执行测试
# sh multi.2.sh &
[1] 5360
sh multi.2.sh &
[1] 6418
[root@bogon shell]#我是2,运行了3秒,整个脚本执行了3秒
我是0,运行了3秒,整个脚本执行了3秒
我是1,运行了3秒,整个脚本执行了3秒
我是5,运行了3秒,整个脚本执行了6秒
我是3,运行了3秒,整个脚本执行了6秒
我是4,运行了3秒,整个脚本执行了6秒
我是6,运行了3秒,整个脚本执行了9秒
我是8,运行了3秒,整个脚本执行了9秒
我是7,运行了3秒,整个脚本执行了9秒
我是9,运行了3秒,整个脚本执行了12秒
10 aa
在另一个ssh终端观察进程的运行
watch -d 'ps aux | grep multi.2.sh | grep -v grep'
Every 2.0s: ps aux | grep multi.2.sh | grep -v grep Fri May 11 04:18:51 2012
root 5360 0.1 0.9 106084 1272 pts/0 S 04:18 0:00 sh multi.2.sh
root 5400 0.0 0.3 106084 548 pts/0 S 04:18 0:00 sh multi.2.sh
root 5401 0.0 0.3 106084 548 pts/0 S 04:18 0:00 sh multi.2.sh
root 5404 0.0 0.3 106084 548 pts/0 S 04:18 0:00 sh multi.2.sh
可以看到同一时间只有4个进程(其中一个是shell本身(pid=5360))，子进程数量得到了控制。
或者：
#!/bin/bash
# 2006-7-12, by wwy
#———————————————————————————–
# 此例子说明了一种用wait、read命令模拟多线程的一种技巧
# 此技巧往往用于多主机检查，比如ssh登录、ping等等这种单进程比较慢而不耗费cpu的情况
# 还说明了多线程的控制
#———————————————————————————–
function a_sub { # 此处定义一个函数，作为一个线程(子进程)
sleep 3 # 线程的作用是sleep 3s
}
tmp_fifofile="/tmp/$$.fifo"
mkfifo $tmp_fifofile # 新建一个fifo类型的文件
exec 6<>$tmp_fifofile # 将fd6指向fifo类型
rm $tmp_fifofile
thread=15 # 此处定义线程数
for ((i=0;i
echo
done >&6 # 事实上就是在fd6中放置了$thread个回车符
for ((i=0;i<50;i++));do # 50次循环，可以理解为50个主机，或其他
read -u6
# 一个read -u6命令执行一次，就从fd6中减去一个回车符，然后向下执行，
# fd6中没有回车符的时候，就停在这了，从而实现了线程数量控制
{ # 此处子进程开始执行，被放到后台
a_sub && { # 此处可以用来判断子进程的逻辑
echo "a_sub is finished"
} || {
echo "sub error"
}
echo >&6 # 当进程结束以后，再向fd6中加上一个回车符，即补上了read -u6减去的那个
} &
done
wait # 等待所有的后台子进程结束
exec 6>&- # 关闭df6
exit 0
sleep 3s，线程数为15，一共循环50次，所以，此脚本一共的执行时间大约为12秒
即：
15×3=45, 所以 3 x 3s = 9s
(50-45=5)<15, 所以 1 x 3s = 3s
所以 9s + 3s = 12s
$ time ./multithread.sh >/dev/null
real 0m12.025s
user 0m0.020s
sys 0m0.064s
而当不使用多线程技巧的时候，执行时间为：50 x 3s = 150s。
此程序中的命令
mkfifo tmpfile
和linux中的命令
mknod tmpfile p
效果相同。区别是mkfifo为POSIX标准，因此推荐使用它。该命令创建了一个先入先出的管道文件，并为其分配文件标志符6。管道文件是进程之 间通信的一种方式，注意这一句很重要
exec 6<>$tmp_fifofile # 将fd6指向fifo类型
如果没有这句，在向文件$tmp_fifofile或者&6写入数据时，程序会被阻塞，直到有read读出了管道文件中的数据为止。而执行了上面这一句后就可以在程序运行期间不断向fifo类 型的文件写入数据而不会阻塞，并且数据会被保存下来以供read程序读出。
总结一下：
方案1：使用”&”使命令后台运行
在linux中，在命令的末尾加上&符号，则表示该命令将在后台执行，这样后面的命令不用等待前面的命令执行完就可以开始执行了。示例中的循环体内有多条命令，则可以以{}括起来，在大括号后面添加&符号。
#/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"
运行结果：
startTime: 194147
endTime: 194147
[j-tester@merger142 ~/bin/multiple_process]$ 1
2
3
4
5
6
7
8
9
10
通过结果可知，程序没有先打印数字，而是直接输出了开始和结束时间，然后显示出了命令提示符[j-tester@merger142 ~/bin/multiple_process]$(出现命令提示符表示脚本已运行完毕)，然后才是数字的输出。这是因为循环体内的命令全部进入后台，所以均在sleep了1秒以后输出了数字。开始和结束时间相同，即循环体的执行时间不到1秒钟，这是由于循环体在后台执行，没有占用脚本主进程的时间。
方案2：命令后台运行+wait命令
解决上面的问题，只需要在上述循环体的done语句后面加上wait命令，该命令等待当前脚本进程下的子进程结束，再运行后面的语句。
#/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"
运行结果：
1
2
3
4
5
6
7
9
8
10
startTime: 194221
endTime: 194222
但这样依然存在一个问题：
因为&使得所有循环体内的命令全部进入后台运行，那么倘若循环的次数很多，会使操作系统在瞬间创建出所有的子进程，这会非常消耗系统的资源。如果循环体内的命令又很消耗系统资源，则结果可想而知。
方案3：使用文件描述符控制并发数
最好的方法是并发的进程是可配置的。
#/bin/bash
all_num=10
thread_num=5
a=$(date +%H%M%S)
tempfifo="my_temp_fifo"
mkfifo ${tempfifo}
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
{
sleep 1
echo ${num}
echo "" >&6
} &
}
done
wait
exec 6>&-
b=$(date +%H%M%S)
echo -e "startTime:\t$a"
echo -e "endTime:\t$b"
运行结果：
1
3
2
4
5
6
7
8
9
10
startTime: 195227
endTime: 195229
这个方案有时通不过 mkfifo ${tempfifo} ，那么就才用更简单的方法来控制：
for ARG in $*; do
command $ARG &
NPROC=$(($NPROC+1))
if [ "$NPROC" -ge 4 ]; then
wait
NPROC=0
fi
done
4 是最大线程，command 是你要执行的代码。
方案4：使用xargs -P控制并发数
xargs命令有一个-P参数，表示支持的最大进程数，默认为1。为0时表示尽可能地大，即方案2的效果。
#/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"
运行结果：
1
2
3
4
5
6
8
7
9
10
startTime: 195257
endTime: 195259
方案5：使用GNU parallel命令控制并发数
GNU parallel命令是非常强大的并行计算命令，使用-j参数控制其并发数量。
#/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"
运行结果：
1
2
3
4
5
6
7
8
9
10
startTime: 195616
endTime: 195618
总结
“多线程”的好处不言而喻，虽然shell中并没有真正的多线程，但上述解决方案可以实现“多线程”的效果，重要的是，在实际编写脚本时应有这样的考虑和实现。
另外：
方案3、4、5虽然都可以控制并发数量，但方案3显然写起来太繁琐。
方案4和5都以非常简洁的形式完成了控制并发数的效果，但由于方案5的parallel命令非常强大，所以十分建议系统学习下。
方案3、4、5设置的并发数均为5，实际编写时可以将该值作为一个参数传入。
相关
Related Posts
Linux Shell脚本入门教程系列之(二)第一个shell脚本
本文是Linux Shell脚本系列教程的第(二)篇，更多shell教程请看：Linux Shell脚本系列教程 通过上一篇教程的学习，相信大家已经能够对shell建立起一个大体的印象了，接下来，我们通过一个最简单的脚本来继续深入对shell的学习。 新建shell脚本 新建一个文件，扩展名为sh(sh代表shell)，或者其他任意名字，其实扩展名并不影响脚本执行，见名知意就好，这里用sh是为了便于分辨。 在你新建的文件中输入以下内容： #!/bin/bash echo…
Linux Shell脚本入门教程系列之(一)Shell简介
本文是Linux Shell脚本系列教程的第(一)篇，更多shell教程请看：Linux Shell脚本系列教程 想要学习linux,shell知识必不可少，今天就给大家来简单介绍下shell的基本知识。 Shell简介 Shell自身是一个用C语言编写的程序，是用户来使用Unix或Linux的桥梁，用户的大部分工作都需要通过Shell来完成。只有熟练使用shell，才能熟练掌握linux。 可以说：Shell既是一种命令语言，又是一种程序设计语言。 作为命令语言，它可以交互式地解释和执行用户输入的命令；而作为程序设计语言，它可以定义各种变量和参数，并提供了许多在高级语言中才具有的控制结构，包括循环和分支。 Shell虽然不是Unix/Linux系统内核的一部分，但它调用了系统核心的大部分功能来执行程序、建立文件并以并行的方式来协调各个程序的运行。…
Linux: Shell脚本备份MySQL数据库, Linux shell script for database backup
Shell脚本是我们写不同类型命令的一种脚本，这些命令在这一个文件中就可以执行。我们也可以逐一敲入命令手动执行。如果我们要使用shell脚本就必须在一开始把这些命令写到一个文本文件中，以后就可以随意反复运行这些命令了。 我首先要在本文带给你的是完整脚本。后面会对该脚本做说明。我假定你已经知道shell scripting、 mysqldump和crontab。 适用操作系统：任何Linux或UNIX。 主脚本(用于备份mysql数据库)： 该Shell脚本可以自动备份数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。 1. 分别建立目录“backups”和“history” mkdir…
921
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
