精华内容
下载资源
问答
  • Shell脚本,并发分组执行命令,如并发发送HTTP请求:发送注册请求共计10个,分2组,每组5条。
  • Linux Shell多进程并发以及并发控制

    千次阅读 2018-06-30 18:22:01
    1. 基础知识准备 1.1. linux后台进程 Unix是一个多任务系统,允许多用户同时运行多个程序。shell的元字符&...字符,该命令就会被送往到linux后台执行,而终端又可以继续输入下一个命令了。 比如: ...




    1. 基础知识准备

    1.1. linux后台进程

    Unix是一个多任务系统,允许多用户同时运行多个程序。shell的元字符&提供了在后台运行不需要键盘输入的程序的方法。输入命令后,其后紧跟&字符,该命令就会被送往到linux后台执行,而终端又可以继续输入下一个命令了。
    比如:

    sh a.sh &
    sh b.sh &
    sh c.sh &
     
    • 1
    • 2
    • 3

    这三个命令就会被同时送往linux后台执行,在这个程度上,认为这三个命令并发执行了。

    1.2. linux文件描述符

    文件描述符(缩写fd)在形式上是一个非负整数。实际上,它是一个索引值,指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时,内核向进程返回一个文件描述符。每一个unix进程,都会拥有三个标准的文件描述符,来对应三种不同的流:

    文件描述符名称
    0Standard Input
    1Standard Output
    2Standard Error

    每一个文件描述符会对应一个打开文件,同时,不同的文件描述符也可以对应同一个打开文件;同一个文件可以被不同的进程打开,也可以被同一个进程多次打开。

    /proc/PID/fd中,列举了进程PID所拥有的文件描述符,例如

    #!/bin/bash
    source /etc/profile;
    
    # $$表示当前进程的PID</span>
    PID=$$
    
    # 查看当前进程的文件描述符指向
    ll /proc/$PID/fd
    echo "-------------------";echo
    
    # 文件描述符1与文件tempfd1进行绑定
    ( [ -e ./tempfd1 ] || touch ./tempfd1 ) && exec 1<>./tempfd1
    
    # 查看当前进程的文件描述符指向
    ll /proc/$PID/fd
    echo "-------------------";echo;
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    [ouyangyewei@localhost learn_linux]$ sh learn_redirect.sh 
    total 0
    lrwx------. 1 ouyangyewei ouyangyewei 64 Jan  4 22:17 0 -> /dev/pts/0
    lrwx------. 1 ouyangyewei ouyangyewei 64 Jan  4 22:17 1 -> /dev/pts/0
    lrwx------. 1 ouyangyewei ouyangyewei 64 Jan  4 22:17 2 -> /dev/pts/0
    
    
    
    
    

    lr-x——. 1 ouyangyewei ouyangyewei 64 Jan 4 22:17 255 -> /home/ouyangyewei/workspace/learn_linux/learn_redirect.sh

    [ouyangyewei@localhost learn_linux]$ cat tempfd1
    total 0
    lrwx——. 1 ouyangyewei ouyangyewei 64 Jan 4 22:17 0 -> /dev/pts/0
    lrwx——. 1 ouyangyewei ouyangyewei 64 Jan 4 22:17 1 -> /home/ouyangyewei/workspace/learn_linux/tempfd1
    lrwx——. 1 ouyangyewei ouyangyewei 64 Jan 4 22:17 2 -> /dev/pts/0
    lr-x——. 1 ouyangyewei ouyangyewei 64 Jan 4 22:17 255 -> /home/ouyangyewei/workspace/learn_linux/learn_redirect.sh
    ——————-

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    上述的例子中第12行,将文件描述符1与文件tempfile进行了绑定,此后,文件描述符1指向了tempfile文件,标准输出被重定向到了文件tempfile中。

    1.3. linux管道

    在Unix或类Unix操作系统中,管道是一个由标准输入输出链接起来的进程集合,因此,每一个进程的输出将直接作为下一个进程的输入,

    linux管道包含两种:

    • 匿名管道
    • 命名管道

    管道有一个特点,如果管道中没有数据,那么取管道数据的操作就会滞留,直到管道内进入数据,然后读出后才会终止这一操作;同理,写入管道的操作如果没有读取管道的操作,这一动作就会滞留。

    1.3.1. 匿名管道

    在Unix或类Unix操作系统的命令行中,匿名管道使用ASCII中垂直线|作为匿名管道符,匿名管道的两端是两个普通的,匿名的,打开的文件描述符:一个只读端和一个只写端,这就让其它进程无法连接到该匿名管道。

    例如:

    cat file | less
     
    • 1

    为了执行上面的指令,Shell创建了两个进程来分别执行catless。下图展示了这两个进程是如何使用管道的:
    unix_unnamed_pipe
    有一点值得注意的是两个进程都连接到了管道上,这样写入进程cat就将其标准输出(文件描述符为fd 1)连接到了管道的写入端,读取进程less就将其标准输入(文件描述符为fd 0)连接到了管道的读入端。实际上,这两个进程并不知道管道的存在,它们只是从标准文件描述符中读取数据和写入数据。shell必须要完成相关的工作。

    1.3.2. 命名管道(FIFO,First In First Out)

    命名管道也称FIFO,从语义上来讲,FIFO其实与匿名管道类似,但值得注意:

    • 在文件系统中,FIFO拥有名称,并且是以设备特俗文件的形式存在的;
    • 任何进程都可以通过FIFO共享数据;
    • 除非FIFO两端同时有读与写的进程,否则FIFO的数据流通将会阻塞;
    • 匿名管道是由shell自动创建的,存在于内核中;而FIFO则是由程序创建的(比如mkfifo命令),存在于文件系统中;
    • 匿名管道是单向的字节流,而FIFO则是双向的字节流;

    比如,可以利用FIFO实现单服务器、多客户端的应用程序:
    unix_named_pipe


    有了上面的知识准备,现在可以开始讲述,linux多进程并发时,如何控制每次并发的进程数。

    2. linux多进程并发数控制

    最近小A需要生产2015年全年的KPI数据报表,现在小A已经将生产脚本写好了,生产脚本一次只能生产指定一天的KPI数据,假设跑一次生产脚本需要5分钟,那么:
    * 如果是循环顺序执行,那么需要时间:5 * 365 = 1825 分钟,约等于 6 天
    * 如果是一次性放到linux后台并发执行,365个后台任务,系统可承受不住哦!

    既然不能一次性把365个任务放到linux后台执行,那么,能不能实现自动地每次将N个任务放到后台并发执行呢?当然是可以的啦。

    #! /bin/bash
    source /etc/profile;
    
    # -----------------------------
    
    tempfifo=$$.fifo        <span class="hljs-comment"># $$表示当前执行文件的PID
    begin_date=$1           # 开始时间
    end_date=$2             # 结束时间
    
    if [ $# -eq 2 ] 
    then
        if [ "$begin_date</span>"</span> \&amp;gt; <span class="hljs-string">"<span class="hljs-variable">$end_date" ]
        then
            echo "Error! $begin_date</span> is greater than <span class="hljs-variable">$end_date"
            exit 1;
        fi
    else
        echo "Error! Not enough params."
        echo "Sample: sh loop_kpi 2015-12-01 2015-12-07"
        exit 2;
    fi
    
    # -----------------------------
    
    trap "exec 1000>&-;exec 1000<&-;exit 0" 2
    mkfifo $tempfifo
    exec 1000<>$tempfifo
    rm -rf $tempfifo
    
    for ((i=1; i<=8; i++))
    do
        echo >&1000
    done
    
    while [ $begin_date</span> != <span class="hljs-variable">$end_date ]
    do
        read -u1000
        {
            echo $begin_date
            hive -f kpi_report.sql --hivevar date=$begin_date
            echo >&1000
        } &
    
        begin_date=`date -d "+1 day $begin_date" +"%Y-%m-%d"`
    done
    
    wait
    echo "done!!!!!!!!!!"
     
    • 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
    • 第6~22行:比如:sh loop_kpi_report.sh 2015-01-01 2015-12-01
      • $1表示脚本入参的第一个参数,等于2015-01-01
      • $2表示脚本入参的第二个参数,等于2015-12-01
      • $#表示脚本入参的个数,等于2
      • 第13行用于比较传入的两个日期的大小,\>是转义
    • 第26行:表示在脚本运行过程中,如果接收到Ctrl+C中断命令,则关闭文件描述符1000的读写,并正常退出
      • exec 1000>&-;表示关闭文件描述符1000的写
      • exec 1000<&-;表示关闭文件描述符1000的读
      • trap是捕获中断命令
    • 第27~29行:
      • 第27行,创建一个管道文件
      • 第28行,将文件描述符1000与FIFO进行绑定,<读的绑定,>写的绑定,<>则标识对文件描述符1000的所有操作等同于对管道文件$tempfifo的操作
      • 第29行,可能会有这样的疑问:为什么不直接使用管道文件呢?事实上这并非多此一举,管道的一个重要特性,就是读写必须同时存在,缺失某一个操作,另一个操作就是滞留,而第28行的绑定文件描述符(读、写绑定)正好解决了这个问题
    • 第31~34行:对文件描述符1000进行写入操作。通过循环写入8个空行,这个8就是我们要定义的后台并发的线程数。为什么是写空行而不是写其它字符?因为管道文件的读取,是以行为单位的
    • 第37~42行:
      • 第37行,read -u1000的作用就是读取管道中的一行,在这里就是读取一个空行;每次读取管道就会减少一个空行
      • 第39~41行,注意到第42行结尾的&吗?它表示进程放到linux后台中执行
      • 第41行,执行完后台任务之后,往文件描述符1000中写入一个空行。这是关键所在了,由于read -u1000每次操作,都会导致管道减少一个空行,当linux后台放入了8个任务之后,由于文件描述符1000没有可读取的空行,将导致read -u1000一直处于等待。

    3. 参考资料



    展开全文
  • 一般我们在linux上十一shell命令的批量执行操作,一般使用for或者while 循环进行操作,但是这样...将被执行的命令运行为后台执行,可以实现并发执行多条命令; for ((i=0;i<10;i++));do echo "done ";done &...

    一般我们在linux上十一shell命令的批量执行操作,一般使用for或者while 循环进行操作,但是这样有一个问题,for或者while本质上是串行的,并不能,如果某一个命令执行耗费的时间比较长,就会等待很长的时间,很浪费时间;

    将被执行的命令运行为后台执行,可以实现并发执行多条命令;

    for ((i=0;i<10;i++));do echo "done ";done &  wait
    

      

    但是上述方法,如果在i的值很大的时候,会产生大量的进行,造成系统严重的问题,所以,需要控制进行数,下面的脚本会保证同一时间只有10个进程在运行;

    [root@linux-node1 ~]# cat parallel.sh 
    #!/bin/sh
    
    tempfifo=$$.fifo
    echo $tempfifo
    trap "exec 100>&-;exec 1000<&-;exit 0" 2
    mkfifo $tempfifo
    exec 1000<>$tempfifo
    rm -rf $tempfifo
    
    for ((i=0;i<10;i++))
    do
       echo >&1000
    done
    
    for((i=0;i<300;i++))
    do
    read -u1000
    {
       sleep 5 
       echo "Done!"
       echo $i
       echo >&1000
    }&
    echo "--------------"
    done
    wait
    
    echo "done !!!!!!!!!"
    

      

    转载于:https://www.cnblogs.com/cqq-20151202/p/6702954.html

    展开全文
  • Shell脚本中的多任务并发执行 需求 实现一个脚本能够使用ping检测网络的连通性 可以同时检测多个IP地址, 并且将检测结果输出 分析 正常情况下,Shell脚本中的命令是串行执行的,当一条命令执行完才会执行接下来的...

    Shell脚本中的多任务并发执行

    需求

    1. 实现一个脚本能够使用ping检测网络的连通性
    2. 可以同时检测多个IP地址, 并且将检测结果输出

    分析

    正常情况下,Shell脚本中的命令是串行执行的,当一条命令执行完才会执行接下来的命令。例如:

    #!/bin/bash
    for i in {1..10};do
    	echo $i 
    done
    echo "END"
    

    结果如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    END
    
    

    可见,循环体中的“echo $i”命令是串行执行的。但是如果所执行的命令耗时比较长,这就会导致整个程序的执行时间非常长,甚至可能导致程序执行时卡住而失去响应。

    这里,我们的需求是:编写一个脚本,扫描192.168.0.0/24网络里某个区间网段有哪些主机在线,能ping通就认为在线。下面是写好的代码:

    #!/bin/bash
    for i in {65,66,67,72,73,68};do
            ip="192.168.0.$i"
            ping -c 2 $ip &> /dev/null && echo $ip is up 
    done
    

    这里对脚本中使用的ping命令稍作说明:Linux中的ping命令在执行后会连续不断地发包,而且使用了“-c”选项,指定只发2次包,如果能收到响应,就认为目标主机在线。

    从逻辑上看,这个脚本没有问题,但是由于要对网络中的多个IP地址轮流执行ping命令,在执行后耗时将非常长,而且此时的脚本无法使用Ctrl+C强制终止,只能使用Ctrl+Z转入后台,然后再用kill命令强制结束进程。

     [root@localhost ~]# bash pinghost.sh
    192.168.0.65 is up
    192.168.0.66 is up
    ^C
    ^Z
    [1]+  已停止               bash pinghost.sh
    [root@localhost ~]# jobs -l                             #查看后台工作任务
    [1]+ 12496 停止                  bash pinghost.sh
    [root@localhost ~]# kill -9 12496                      #强制结束进程
    [root@localhost ~]# 
    [1]+  已杀死               bash pinghost.sh
    

    实际上,在这个脚本中所循环执行的ping命令之间并没有依赖关系,也就是说不必非要等到“ping 192.168.0.65”结束之后才能接着执行“ping 192.168.0.66”,所有的这些ping命令完全可以并发执行

    如果是使用Python,则可以借助于多线程技术来实现命令的并发执行,而Shell不支持多线程,因此只能采用多进程的方式。具体的实现方法就是在要并发执行的命令后面加上“&”,将其转入后台执行,这样就可以在执行完一条命令之后,不必等待其执行结束,就立即转去执行下一条命令。修改后的代码如下:

    #!/bin/bash
    for i in {1..10};do
    	echo $i &
    done
    echo "END"
    

    执行结果如下:

    1
    2
    3
    4
    8
    END
    5
    10
    6
    9
    

    可见,在并发执行时不能保证命令的执行顺序,而且本应在整个循环执行结束之后再执行的echo "END"命令,却在程序一开始就被执行了。所以在并发执行时,我们通常都需要保证在循环体中的所有命令都执行完后再向后执行接下来的命令,这时就可以使用 wait命令来实现
    在Shell中使用wait命令,相当于其它高级语言里的多线程同步。修改代码如下:

     #!/bin/bash
    for i in {1..10};do
    	echo $i &
    done
    wait
    echo "END"
    

    此时的执行结果如下:

    1
    2
    3
    4
    5
    8
    6
    9
    7
    10
    END
    
    

    这样执行结果就正常了。

    代码

    回到我们的问题上来,如果要检测多个IP的网络连通性,也可以使用上述过程的思路,代码如下:

    #!/bin/bash
    for i in {65,66,67,72,73,68};do
            ip="192.168.0.$i"
            ping -c 2 $ip &> /dev/null && echo $ip is up &
    done
    wait
    

    网络的检测结果如下:

    [root@localhost ~]# bash pinghost.sh
    192.168.0.65 is up
    192.168.0.66 is up
    192.168.0.72 is up
    192.168.0.73 is up
    192.168.0.67 is up
    192.168.0.68 is up
    

    因此,当在循环执行的命令之间没有依赖关系时,完全可以采用并发执行的方式,这样可以大幅提高代码执行效率。

    当然,并发执行也有缺陷,就是当需要并行执行的命令数量特别多,特别是所执行的命令占用的系统资源非常多时,可能会将整个系统的资源全部耗尽,影响其它程序的运行,因此还可以借助其它技术来限制并发执行的进程数量。

    展开全文
  • >&8 done #创建for循环执行ping语句,通过管道控制最大同时并行进程数,使用完一次管道后再重新写入一次,始终保持管道中有5行可读 for i in {1..254} do read -u 8 { ip="10.1.100.$i" ping -c1 -W2 $ip &> /...
    #!bin/bash
    num=5
    fifofile="/tmp/$$.fifo"
    
    #创建管道文件,以8作为管道符,删除不影响句柄使用
    mkfifo $fifofile
    exec 8<> $fifofile
    rm $fifofile
    
    #创建for循环使得管道中初始化已存在5行空行
    for i in `seq $num`
    do
    	echo "" >&8
    done
    #创建for循环执行ping语句,通过管道控制最大同时并行进程数,使用完一次管道后再重新写入一次,始终保持管道中有5行可读
    for i in {1..254}
    do
    	read -u 8
    	{
    	ip="10.1.100.$i"
    	ping -c1 -W2 $ip &> /dev/null
    	if [ $? -eq 0 ];then
    		echo "$ip up..."
    	else
    		echo "$ip done..."
    	fi
    	echo >&8
    	}&
    done
    wait
    echo "Script run finish..."
    
    展开全文
  • Linux Shell实现多进程并发执行

    万次阅读 2017-08-18 10:16:58
    在不加控制的模式下,不管有多少任务,全部都后台执行。也就是说,在这种情况下,有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况: 实例一:正常情况脚本 ——————————————————...
  • Shell语言并发执行多条命令

    千次阅读 2019-10-29 17:28:37
    shell语言的并发 Default模式下,shell命令是阻塞执行的,可以通过其后添加&让这条命令异步执行,如: sleep 10 & 执行这条命令后,并不会阻塞10秒,而是立即返回。 如果将这种方法用在while循环中,...
  • 在实验楼中完成实验七《Linux Shell实现模拟多进程并发执行》, 在你对Linux Shell实现模拟多进程并发执行实验做完之后,是否引发你深入思考,shell程序也是批处理程序,对批处理程序也有了初步认识。请写实验报告。...
  • 一、flock声明 Usage: flock [options] <file>|<directory> <command> [<argument>...] flock [options] <file>|<directory>...Manage file locks from shell scripts.
  • shell后台并发执行的最佳实践

    万次阅读 2018-04-14 16:28:42
    一、shell如何在后台执行1.nohup命令通常我们都是远程登录linux终端,而当我们退出终端时在之前终端运行的程序都会终止,有时候先想要退出终端也要程序继续执行这时nohup就登场了。nohup命令可以将程序以忽略挂起...
  • 在不加控制的模式下,不管有多少任务,全部都后台执行。也就是说,在这种情况下,有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况: 实例一:正常情况脚本 ——————————————————...
  • Linux Shell实现模拟多进程并发执行 实现多进程并发执行的步骤: 创建文件用来写脚本语言 test1.sh 在vim的文本编辑器中编辑脚本文件 tes1t.sh 保存后在终端执行 尝试不同的代码观察并发执行 步骤实现: 创建...
  • 正常情况下,Shell脚本中的命令是串行执行的,当一条命令执行完才会执行接下来的命令。比如下面这段代码:#!/bin/bashfor i in {1..10};doecho $idoneecho "END"执行结果:12345678910END可以看到,循环体中的“echo...
  • (一)多进程并发执行是使用后台任务来实现任务的“多进程化”。在不加控制的模式下,不管有多少任务,全部都后台执行。也就是说,在这种情况下,有多少任务就有多少“进程”在同时执行。 (二)实验中要用到的函数 ...
  • Linux shell实现多进程并发执行

    千次阅读 2019-08-15 11:57:10
    在不加控制的模式下,不管有多少任务,全部都后台执行。也就是说,在这种情况下,有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况: 实例一:正常情况脚本 ————————————————————...
  • linux测试使用shell并发脚本

    热门讨论 2011-01-25 15:39:05
    linux测试使用shell并发脚本,这个只是一个脚本!
  • shell实现队列控制并发执行脚本

    千次阅读 2018-07-31 17:46:05
    在工作中,个人需要用到统计数据的脚本,比如对批量文件过滤关键字...通过查找资料,对脚本进行调整,实现并发执行,具体如下: #!/bin/bash date DIR=/test/log/ FILE_NAME=65535_`date +"%Y%m%d"`;...
  • [Linux]Linux Shell多进程并发以及并发控制

    万次阅读 多人点赞 2016-09-12 12:56:59
    Unix是一个多任务系统,允许多用户同时运行多个程序。shell的元字符&提供了在后台运行不需要键盘输入的程序的方法...输入命令后,其后紧跟&字符,该命令就会被送往到linux后台执行,而终端又可以继续输入下一个命令了。
  • 1. 基础知识准备 1.1. linux后台进程 ...字符,该命令就会被送往到linux后台执行,而终端又可以继续输入下一个命令了。  比如: sh a.sh &amp; sh b.sh &amp; sh c.sh &amp; 这三个命令就...
  • Shell脚本中的命令是串行执行的,必须等到前一条命令执行完后才执行接下来的命令,但是如果我有一大批的的命令需要执行,而且互相又没有影响的情况下(有影响的话就比较复杂了),那么就要使用命令的并发执行了。...
  • 网上搜索能找到一些并发控制方法,如一、linux shell多进程以及二、Linux Shell多进程并发以及并发控制。        两篇文章的方法思路一致,仅在实现细节上有差异。其中,文章一的方法在加锁...
  • shell控制并发数量——脚本方法

    千次阅读 2020-09-17 12:56:00
    文章目录说明代码如下代码(附带解释)纯代码echo >&6 放错位置说明正确位置错误之——位置错误错误之——... ps:只要没有涉及到fd要释放的,就不需要折腾,弄控制并发的步骤。 啥?啥是fd? 下面放个图简单
  • 给大家分享如何使用shll解决用ab每隔30分钟并发一次休息10分钟,需要的朋友可以参考下
  • Linux shell ping命令多并发#!/bin/bash#多线程批量ping,有时候多线程使用过多,会导致系统崩溃#用此方法可以进行多并发#创建5个进程thread=5#创建管道文件tem_fifofile=/tmp/$$.fifomkfifo $tmp_fifofileexec 8 $...
  • Linuxshell脚本实现多并发

    千次阅读 2020-06-30 11:24:52
    如果这些命令相互之间是独立的,则可以使用“并发”的方式执行这些命令,这样可以更好地利用系统资源,提升运行效率,缩短脚本执行的时间。如果命令相互之间存在交互,则情况就复杂了,那么不建议使用shell脚本来...
  • /bin/bash# ----------------------------------------------------tmpfile=./$$.pid #$$是获取当前SHELL脚本进程的PIDmkfifo $tmpfile #生成一个FIFO管道文件exec 1000&lt;&gt;$tmpfile #绑定文件描述符...
  • shell并发编程

    2016-11-25 16:54:24
    shell脚本中的命令是串行执行的,必须等到前一条命令执行完后才执行下一条命令,但是如果我有一大批的的命令需要执行,而且互相又没有影响的情况下(有影响的话就比较复杂了),那么可以考虑使用命令的并发执行。...
  • linux shell 多线程执行程序

    千次阅读 2019-06-19 09:40:59
    linux shell 多线程执行程序 Shell中并没有真正意义的多线程,要实现多线程可以启动多个后端进程,最大程度利用cpu性能。 直接看代码示例吧。 (1) 顺序执行的代码 #!/bin/bash date for i in `seq 1 5` do { echo ...
  • #!/bin/bash trap "exec 1000&gt;&amp;-;exec 1000&lt;&amp;-;exit 0" 2 mkfifo testfifo ...n++)) #可修改n的值,以减小并发量 do echo &gt;&amp;1000 don...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,122
精华内容 14,848
关键字:

linuxshell并发执行控制

linux 订阅