shell 多线程

最新推荐文章于 2025-07-14 17:22:23 发布
最新推荐文章于 2025-07-14 17:22:23 发布
阅读量671 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： shell 文章标签： shell 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sprita1/article/details/97820337
本文介绍了在Linux Shell中通过命名管道(fifo)实现多线程执行程序的示例，详细展示了如何控制后台进程的数量并保证任务执行的顺序。通过不同情况的代码对比，展示了如何有效地管理和控制进程的并发执行。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

注意下面注释中带“>>>>>”的位置

 

情况1：

#!/bin/bash
temp_fifo_file=$$.info        #以当前进程号，为临时管道取名
mkfifo $temp_fifo_file        #创建临时管道
exec 6<>$temp_fifo_file       #创建标识为6，可以对管道进行读写
rm $temp_fifo_file            #清空管道内容
 
function f_sleep              
{
  sleep 2
} 
 
temp_thread=2                 #进程数
 
for ((i=0;i<temp_thread;i++)) #为进程创建相应的占位
do
  echo                        #每个echo输出一个回车，为每个进程创建一个占位
done >&6                      #将占位信息写入标识为6的管道
 
for ((i=0;i<6;i++))          
do
  read                        #获取标识为6的占位
  {
    f_sleep
    echo $$,$i,`date`
    sleep 5
    echo $$,$i,`date`
    echo >&6                  #>>>>>当任务执行完后，会释放管道占位，所以补充一个占位
  }&                          #>>>>>在后台执行{}中的任务
done <&6                      #将标识为6的管道作为标准输入
 
wait                          #等待所有任务完成
exec 6>&-                     #关闭标识为6的管道
> date ; ./thread_1.sh
Tue Jun 19 17:12:36 TAIST 2012
4032,0,Tue Jun 19 17:12:38 TAIST 2012
4032,1,Tue Jun 19 17:12:38 TAIST 2012
4032,0,Tue Jun 19 17:12:43 TAIST 2012
4032,1,Tue Jun 19 17:12:43 TAIST 2012
4032,2,Tue Jun 19 17:12:45 TAIST 2012
4032,3,Tue Jun 19 17:12:45 TAIST 2012
4032,2,Tue Jun 19 17:12:50 TAIST 2012
4032,3,Tue Jun 19 17:12:50 TAIST 2012
4032,4,Tue Jun 19 17:12:52 TAIST 2012
4032,5,Tue Jun 19 17:12:52 TAIST 2012
4032,4,Tue Jun 19 17:12:57 TAIST 2012
4032,5,Tue Jun 19 17:12:57 TAIST 2012
 
21s

 情况2：

#!/bin/bash
temp_fifo_file=$$.info        #以当前进程号，为临时管道取名
mkfifo $temp_fifo_file        #创建临时管道
exec 6<>$temp_fifo_file       #创建标识为6，可以对管道进行读写
rm $temp_fifo_file            #清空管道内容
 
function f_sleep              
{
  sleep 2
} 
 
temp_thread=2                 #进程数
 
for ((i=0;i<temp_thread;i++)) #为进程创建相应的占位
do
  echo                        #每个echo输出一个回车，为每个进程创建一个占位
done >&6                      #将占位信息写入标识为6的管道
 
for ((i=0;i<6;i++))          
do
  read                        #获取标识为6的占位
  {
    f_sleep
    echo $$,$i,`date`
  }&                          #>>>>>在后台执行{}中的任务
  sleep 5
  echo $$,$i,`date`
  echo >&6                    #>>>>>当任务执行完后，会释放管道占位，所以补充一个占位
done <&6                      #将标识为6的管道作为标准输入
 
wait                          #等待所有任务完成
exec 6>&-                     #关闭标识为6的管道
> date ; ./thread_1.sh
Tue Jun 19 17:18:28 TAIST 2012
6288,0,Tue Jun 19 17:18:30 TAIST 2012
6288,0,Tue Jun 19 17:18:33 TAIST 2012
6288,1,Tue Jun 19 17:18:35 TAIST 2012
6288,1,Tue Jun 19 17:18:38 TAIST 2012
6288,2,Tue Jun 19 17:18:40 TAIST 2012
6288,2,Tue Jun 19 17:18:43 TAIST 2012
6288,3,Tue Jun 19 17:18:45 TAIST 2012
6288,3,Tue Jun 19 17:18:48 TAIST 2012
6288,4,Tue Jun 19 17:18:50 TAIST 2012
6288,4,Tue Jun 19 17:18:53 TAIST 2012
6288,5,Tue Jun 19 17:18:55 TAIST 2012
6288,5,Tue Jun 19 17:18:58 TAIST 2012
 
30s

 情况3：

#!/bin/bash
temp_fifo_file=$$.info        #以当前进程号，为临时管道取名
mkfifo $temp_fifo_file        #创建临时管道
exec 6<>$temp_fifo_file       #创建标识为6，可以对管道进行读写
rm $temp_fifo_file            #清空管道内容
 
function f_sleep              
{
  sleep 2
  echo >&6                    #>>>>>当任务执行完后，会释放管道占位，所以补充一个占位
} 
 
temp_thread=2                 #进程数
 
for ((i=0;i<temp_thread;i++)) #为进程创建相应的占位
do
  echo                        #每个echo输出一个回车，为每个进程创建一个占位
done >&6                      #将占位信息写入标识为6的管道
 
for ((i=0;i<6;i++))          
do
  read                        #获取标识为6的占位
  {
    f_sleep
    echo $$,$i,`date`
  }&                          #>>>>>在后台执行{}中的任务
  sleep 5
  echo $$,$i,`date`
done <&6                      #将标识为6的管道作为标准输入
 
wait                          #等待所有任务完成
exec 6>&-                     #关闭标识为6的管道
> date ; ./thread_1.sh
Tue Jun 19 17:17:06 TAIST 2012
5777,0,Tue Jun 19 17:17:08 TAIST 2012
5777,0,Tue Jun 19 17:17:11 TAIST 2012
5777,1,Tue Jun 19 17:17:13 TAIST 2012
5777,1,Tue Jun 19 17:17:16 TAIST 2012
5777,2,Tue Jun 19 17:17:18 TAIST 2012
5777,2,Tue Jun 19 17:17:21 TAIST 2012
5777,3,Tue Jun 19 17:17:23 TAIST 2012
5777,3,Tue Jun 19 17:17:26 TAIST 2012
5777,4,Tue Jun 19 17:17:28 TAIST 2012
5777,4,Tue Jun 19 17:17:31 TAIST 2012
5777,5,Tue Jun 19 17:17:33 TAIST 2012
5777,5,Tue Jun 19 17:17:36 TAIST 2012
 
30s

 情况4：

#!/bin/bash
temp_fifo_file=$$.info        #以当前进程号，为临时管道取名
mkfifo $temp_fifo_file        #创建临时管道
exec 6<>$temp_fifo_file       #创建标识为6，可以对管道进行读写
rm $temp_fifo_file            #清空管道内容
 
function f_sleep              
{
  sleep 2
  echo >&6                    #>>>>>当任务执行完后，会释放管道占位，所以补充一个占位
} 
 
temp_thread=2                 #进程数
 
for ((i=0;i<temp_thread;i++)) #为进程创建相应的占位
do
  echo                        #每个echo输出一个回车，为每个进程创建一个占位
done >&6                      #将占位信息写入标识为6的管道
 
for ((i=0;i<6;i++))          
do
  read                        #获取标识为6的占位
  {
    f_sleep
    echo $$,$i,`date`
    sleep 5
    echo $$,$i,`date`
  }&                          #>>>>>在后台执行{}中的任务
done <&6                      #将标识为6的管道作为标准输入
 
wait                          #等待所有任务完成
exec 6>&-                     #关闭标识为6的管道
> date ; ./thread_1.sh
Tue Jun 19 17:16:11 TAIST 2012
5367,0,Tue Jun 19 17:16:13 TAIST 2012
5367,1,Tue Jun 19 17:16:13 TAIST 2012
5367,3,Tue Jun 19 17:16:15 TAIST 2012
5367,2,Tue Jun 19 17:16:15 TAIST 2012
5367,4,Tue Jun 19 17:16:17 TAIST 2012
5367,5,Tue Jun 19 17:16:17 TAIST 2012
5367,0,Tue Jun 19 17:16:18 TAIST 2012
5367,1,Tue Jun 19 17:16:18 TAIST 2012
5367,3,Tue Jun 19 17:16:20 TAIST 2012
5367,2,Tue Jun 19 17:16:20 TAIST 2012
5367,4,Tue Jun 19 17:16:22 TAIST 2012
5367,5,Tue Jun 19 17:16:22 TAIST 2012
 
11s
 
--------------------- 
作者：wqq_721 
来源：优快云 
原文：https://blog.youkuaiyun.com/wqq_721/article/details/7968099 
版权声明：本文为博主原创文章，转载请附上博文链接！

 

 

 

 

linux shell 多线程执行程序

Shell中并没有真正意义的多线程，要实现多线程可以启动多个后端进程，最大程度利用cpu性能。

直接看代码示例吧。

(1) 顺序执行的代码

 1 #!/bin/bash
 2 date
 3 for i in `seq 1 5`
 4 do
 5 {
 6     echo "sleep 5"
 7     sleep 5
 8 }
 9 done
10 date

输出：

Sat Nov 19 09:21:51 CST 2016
sleep 5
sleep 5
sleep 5
sleep 5
sleep 5
Sat Nov 19 09:22:16 CST 2016

(2) 并行代码

使用'&'+wait 实现“多进程”实现

按 Ctrl+C 复制代码

 

按 Ctrl+C 复制代码

输出：

Sat Nov 19 09:25:07 CST 2016
sleep 5
sleep 5
sleep 5
sleep 5
sleep 5
Sat Nov 19 09:25:12 CST 2016

 (3) 对于大量处理任务如何实现启动后台进程的数量可控？

　　简单的方法可以使用2层for/while循环实现，每次wait内层循环的多个后台程序执行完成。

　　但是这种方式的问题是，如果内层循环有“慢节点”可能导致整个任务的执行执行时间长。

　　更高级的实现可以看(4)

(4) 使用命名管道(fifo)实现每次启动后台进程数量可控。 

 

参考:https://www.cnblogs.com/xudong-bupt/p/6079849.html

Shell 实现多线程（多任务）
weixin_34203426的博客
08-21 1117
实现方案： 1.命令结尾添加：&amp;amp; #/bin/bash all_num=10 a=$(date +%H%M%S) for num in `seq 1 ${all_num}` do { sleep 1 echo ${num} } &amp;amp; done b=$(date +%H%M%S) echo -e &quot;startTime:\t$a&quot; echo ...
Shell 脚本实现多线程的代码
04-03
一个用Shell脚本实现多线程操作的代码
linux shell 多线程执行程序
weixin_34162228的博客
11-19 629
Shell中并没有真正意义的多线程，要实现多线程可以启动多个后端进程，最大程度利用cpu性能。 直接看代码示例吧。 (1) 顺序执行的代码 1 #!/bin/bash 2 date 3 for i in `seq 1 5` 4 do 5 { 6 echo &quot;sleep 5&quot; 7 sleep 5 8 } 9 done 10 date ...
Shell中怎么实现多线程或多进程
最新发布
wtt6857492的博客
07-14 490
4：使用nohup命令：nohup命令可以让命令在后台运行并忽略HUP信号，从而实现进程的后台运行。2：使用xargs命令：xargs命令可以将标准输入转换为命令行参数，从而实现多个命令的并行执行。1：使用parallel命令：parallel命令可以同时运行多个命令，可以实现多线程的效果。3：使用&符号：您可以在命令后面加上&符号来将命令放入后台运行，这样可以实现多个进程同时运行。2.后台运行：& 使命令在后台运行，终端可以继续输入其他命令。2.:::：参数分隔符，表示后面跟着要并行执行的命令或参数。
shell队列实现线程并发控制
xuleisdjn的专栏
10-20 1151
请看原文http://egon09.blog.51cto.com/9161406/1754317需求：并发检测1000台web服务器状态（或者并发为1000台web服务器分发文件等）如何用shell实现？方案一：（这应该是大多数人都第一时间想到的方法吧） 思路：一个for循环1000次，顺序执行1000次任务。#!/bin/bash start_time=`date +%s` #定义脚本运行的开始时
shell 多线程脚本
weixin_42808782的博客
04-02 3739
shell 多线程脚本实现 方法一： for 循环 加&amp;，指定的所有进程在后台同时运行： [root@node1 sh]# cat process.sh #!/bin/sh #2021年4月2日16:41:37 echo “run 50 process…” for ((i=0;i&lt;50;i++)) do { echo “process $i is running ,sleep 5…” sleep 5 }&amp; done wait echo “total time consume is $S
Shell多线程
weixin_43484854的博客
09-10 1467
执行shell脚本时，本身并不存在真正的多线程，所谓的shell多线程只是把没有完成任务放到后台运行。
shell脚本多线程
moyuanbomo的博客
06-30 1546
shell
shell实现多线程笔记
weixin_34361881的博客
08-21 325
按照shell语法，后一个前台命令必须等待前一个前台命令执行完毕才能进行，这就是所谓的单线程程序。如果两条命令之间有依赖性还好，否则后一条命令就白白浪费了等待的时间了。网上查了一遍，shell并没有真正意义上的多进程。而最简单的节省时间，达到“多线程”效果的办法，是将前台命令变成后台进程，这样一来就可以跳过前台命令的限制了。引用网上例子：实例一：全前台进程：#!/bin/ba...
[shell进阶]——shell多线程
weixin_30505043的博客
07-26 307
关于shell的多线程 1. 多线程并发执行任务，而不用一台台的串行执行，能更快更高效 2. Shell并没有多线程的概念，所以： * 一般使用wait、read等命令技巧性地模拟多线程实 * 使用命名管道（fifo）来实现多线程的控制 3. 用途：需要对多主机批量执行检查或操作时（例如ssh、ping等操作） 分段解析一个例子来理解一个多线程脚本的书写 1. ...
shell多线程实现
花花公子
04-19 196
#!/bin/bash sum=0 for i in {1..1000} do { curl http://127.0.0.1:8080/test?userNamae=AAAAAA } &amp; done wait
shell多线程写法
貓的博客
11-16 514
shell多线程写法笔记
shell实现多线程操作
牧羊人
03-27 1659
业务需求 目前平台有近千台服务器，由于特殊情况，需要时不时的收集获取相关服务器 信息，此处暂时不考虑ansible,saltstack等自动化工具，让临时使用shell 实现，正常都是直接使用循环的方式进行操作，但耗时比较久，要求提高效率， 考虑使用多线程操作 实现逻辑 可以简单理解为如下步骤： 1.想要实现shell的并发，无非就是把循环体里面的指令使用&amp;放入后台进行； 2.使用wa...
shell 命令多线程方法
五月的田野
07-26 3194
生信流程中前后不互相影响的命令（就是后面的流程不依赖前面的输出）可以使用多线程的方式进行处理，可以大大的节省时间。 方式：shell 的for循环do与done之间的代码使用{ }&amp;amp;amp;放在后台执行，然后加上 wait，前面的都执行完后才会执行wait后的命令。 代码如下： for num in `seq 1 10` do { sleep 1 echo ${num} } &amp;amp;amp...
Shell多线程实现
demon7552003的小本本
07-27 810
#!bash # 2014-12-5 # -------------------- # 此例子说明了一种用wait、read命令模拟多线程的一种技巧 # 此技巧往往用于多主机检查，比如ssh登录、ping等等这种单进程比较慢而不耗费cpu的情况 # ------------------------- operation(){ sleep $1 } tmp_fifofile=/tmp...
Shell Script—线程
shouhu010的博客
06-29 466
本文主要介绍shell中的线程、线程中的等待和信号；
Shell实现多进程运行
11-02 1314
原文出处：http://bbs.51cto.com/thread-1104907-1-1.html 根据我个人的理解， 所谓的多进程 只不过是将多个任务放到后台执行而已，很多人都用到过，所以现在讲的主要是控制，而不是实现。 先看一个小shell：   看执行结果：   很明显是8s ============================= 这种不占处理器却有很耗时
Linux shell "多线程"例子
开心就好的专栏
04-06 423
shell多线程? 其实这里说的是多进程. 其实就是开多个后台进程, 然后等它们都结束后, 才认为结束. 举一个最常见的例子, ping一个网段内的所有ip, 看其通断情况. 其他情况都可以套用这个例子来改造: #! /bin/bash # # Distributed under terms of the MIT license. # # 这个并发度是为了同时不会开太多进程, 怕系统资源不够. ...
shell脚本的多线程介绍
techenliu的博客
10-03 2042
shell脚本的多线程介绍
shell 多线程执行
03-28
&lt;think&gt;好的，我现在需要向用户介绍Shell中的多线程执行。首先，我需要明确用户的问题是什么，他们可能想了解如何在Shell脚本中实现并发执行任务，以提高效率。接下来，我得考虑Shell本身是否支持多线程，或者用户是否指的是多进程的方式，因为Shell通常使用子进程来模拟并发。 首先，我应该解释Shell本身并不支持真正的多线程，比如像Java或Python那样的线程模型。Shell脚本默认是顺序执行的，但可以通过一些方法实现并发，比如使用后台运行（&amp;）和wait命令来控制多个进程的并行执行。这实际上是多进程的方式，但在效果上类似于多线程，能够同时处理多个任务。 接下来，我需要介绍具体的实现方法。例如，使用&amp;将命令放到后台运行，这样脚本不会等待该命令完成就继续执行下一个命令。然后，使用wait命令等待所有后台任务完成，这样可以确保在需要的时候同步各进程的结果。 可能还需要提到如何控制并发数量，比如使用命名管道（mkfifo）或类似的技术来创建队列，限制同时运行的进程数目，避免系统资源被耗尽。例如，使用循环和计数器来启动一定数量的后台任务，然后等待其中一部分完成后再启动新的任务，从而控制并发度。 另外，需要提到一些常见的陷阱，比如资源竞争、输出混乱的问题。当多个进程同时向标准输出写入时，输出可能会交错在一起，导致难以阅读。这时候可以考虑将每个进程的输出重定向到不同的文件，或者使用工具如GNU parallel来处理复杂的并行任务，它能够更好地管理输出和资源分配。 还有，GNU parallel是一个强大的工具，可以简化并行处理，用户可能想知道这个工具的基本用法，比如如何用它来并行执行命令，处理输入列表，控制任务数量等。但用户的问题是关于Shell本身的多线程，所以可能需要简要提及这个工具作为扩展。 在结构上，应该先介绍基本概念，然后逐步讲解实现方法，从简单的后台执行到控制并发数量，再到处理输出和推荐工具。同时，需要提供示例代码，帮助用户更好地理解。例如，展示一个使用循环和后台任务来并发处理文件的例子，或者使用队列机制限制并发数的例子。 还要注意语法正确性，在示例中使用正确的Shell语法，比如使用圆括号启动子shell，或者使用wait的正确位置。同时，可能需要提醒用户注意不同Shell之间的差异，比如Bash和Dash可能在语法上有所不同，建议使用Bash以获得更好的功能支持。 最后，总结Shell多线程（实际是多进程）的优缺点，适用场景，以及更高效的工具推荐，比如GNU parallel或者xargs的-P参数，这些都能帮助用户更好地处理并行任务。需要确保回答结构清晰，步骤明确，让用户能够逐步理解和应用这些方法。&lt;/think&gt;在Shell脚本中实现多线程（实际是**多进程并发**）的步骤如下： --- ### 一、基本概念 Shell本身不支持真正的多线程（Thread），但可通过启动多个子进程模拟并行。常用方法： - `&amp;` 符号：将命令放入后台执行 - `wait` 命令：等待所有后台任务完成 - 资源控制：避免过度占用CPU/内存 --- ### 二、基础实现 #### 示例1：简单并行任务 ```bash #!/bin/bash # 启动3个后台任务 task1() { sleep 2; echo &quot;任务1完成&quot;; } task2() { sleep 1; echo &quot;任务2完成&quot;; } task3() { sleep 3; echo &quot;任务3完成&quot;; } task1 &amp; task2 &amp; task3 &amp; wait # 等待所有后台任务结束 echo &quot;所有任务完成&quot; ``` #### 输出结果： ``` 任务2完成 任务1完成 任务3完成 所有任务完成 ``` --- ### 三、控制并发数量 #### 方法1：循环计数器 ```bash #!/bin/bash max_workers=2 # 最大并发数 counter=0 for i in {1..5}; do ( echo &quot;任务 $i 开始&quot; sleep $((RANDOM%3+1)) echo &quot;任务 $i 完成&quot; ) &amp; ((counter++)) if ((counter == max_workers)); then wait # 等待当前批次任务完成 counter=0 fi done wait echo &quot;全部任务结束&quot; ``` #### 方法2：使用命名管道（更精准控制） ```bash #!/bin/bash concurrent=3 tmp_fifo=&quot;/tmp/$$.fifo&quot; mkfifo $tmp_fifo exec 6&lt;&gt;$tmp_fifo rm -f $tmp_fifo for ((i=0; i&lt;$concurrent; i++)); do echo &gt;&amp;6 # 初始化管道令牌 done for i in {1..10}; do read -u6 # 获取令牌 { echo &quot;处理任务 $i&quot; sleep 1 echo &gt;&amp;6 # 归还令牌 } &amp; done wait exec 6&gt;&amp;- echo &quot;执行完毕&quot; ``` --- ### 四、注意事项 1. **输出混乱问题** 各子进程的输出可能交错，可通过重定向解决： ```bash task &gt; output_$i.log 2&gt;&amp;1 &amp; ``` 2. **资源监控** 使用 `top` 或 `htop` 观察CPU/内存占用 3. **任务隔离** 每个子进程是独立环境，变量需显式传递 --- ### 五、高级工具推荐 1. **GNU Parallel** ```bash seq 10 | parallel -j 4 &quot;echo Processing {}; sleep 1&quot; ``` 2. **xargs 的 -P 参数** ```bash seq 10 | xargs -I{} -P4 sh -c &#39;echo 处理{}; sleep 1&#39; ``` --- ### 六、适用场景 - 批量文件处理（如压缩/格式转换） - API并发请求测试 - 日志并行分析 --- 通过合理控制并发数，Shell脚本可实现效率提升数倍至数十倍，但需注意避免过度并发导致系统负载过高。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值