Perl多进程实战

最新推荐文章于 2015-09-24 18:56:22 发布
最新推荐文章于 2015-09-24 18:56:22 发布
阅读量2.6k 收藏 4
点赞数
分类专栏： PERL 文章标签： perl signal 任务 linux 活动 语言

转自http://bbs.scmroad.com/viewthread.php?tid=3917

perl作为一种解释性的语言，很受广大系统管理员的欢迎，好处么就不多说了，坏处也有不少，例如对线程的支持，就一直不咋地，所以大多数情况下，我们都需要多个进程，来帮助我们完成 工作，闲话少说，上代码。
#!/usr/bin/perl
# test_proc.pl
# test multi process
# create by lianming: 2009-08-12
use strict;
use warnings;
## == fork a new process ==
my $pid = fork();
if (!defined($pid)) {
    print "Error in fork: $!";
    exit 1;
}
if ($pid == 0) {
    ## == child proc ==
    print "Child: My pid = $$\n";
    sleep(5);
    print "Child: end\n";
    exit 0;
} else {
    ## == parent proc ==
    print "Parent My pid = $$, and my child's pid = $pid\n";
    sleep(5);
    print "Parent: end\n";
}
exit 0;
     执行结果如下：
Child: My pid = 19481
Parent My pid = 19480, and my child's pid = 19481
（5秒钟等待）
Child: end
Parent: end
     父进程派生子进程，之需要一条命令，那就是fork，fork函数的返回值赋给一个变量，上例中赋给了"$pid"，接下来，就要根据$pid值的不同，来分三种情况了。
     1、fork失败的情况：这个时候，$pid处于未定义的状态，上例中做的一个"if (!defined($pid))"的判断，如果为真，说明$pid未定义，fork失败，这个时候就要打印错误信息，并且退出。
     2、子进程：如果是子进程，那么$pid的值为0，就是上例中"if ($pid == 0)"条件为真的状况，在"$pid == 0"的时候，那就都是子进程了，上例中，子进程将自己的pid打出来，为19481。
     3、父进程：如果是父进程，那么$pid的值为它派生出的子进程的pid，也就是不为0，就是else的情况，上例中把$pid打出来，可以看到，也是 19481，就是子进程的pid值。
     这只是一个最简单的例子，一个父进程派生一个子进程，再稍微复杂一点，一个父进程派生多个子进程，代码如下：
#!/usr/bin/perl
# test_proc_1.pl
# test multi process
# create by lianming: 2009-08-12
use strict;
use warnings;

for (my $i = 0; $i < 10; $i ++) {
    ## == fork a new process ==
    my $pid = fork();
    if (!defined($pid)) {
        print "Error in fork: $!";
        exit 1;
    }
    if ($pid == 0) {
        ## == child proc ==
        print "Child $i : My pid = $$\n";
        sleep(5);
        print "Child $i : end\n";
        exit 0;
    }
    sleep(1);
}
exit 0;
     这个例子就是，父进程执行一个循环，每次循环都fork一个子进程，子进程执行完以后退出，每次循环都等待1s，循环10次。
     执行结果如下：
Child 0 : My pid = 20499
Child 1 : My pid = 20500
Child 2 : My pid = 20501
Child 3 : My pid = 20502
Child 4 : My pid = 20503
Child 0 : end
Child 5 : My pid = 20506
Child 1 : end
Child 6 : My pid = 20507
Child 2 : end
Child 7 : My pid = 20508
Child 3 : end
Child 8 : My pid = 20509
Child 4 : end
Child 9 : My pid = 20510
Child 5 : end
[root@localhost /tmp]
# Child 6 : end
Child 7 : end
Child 8 : end
Child 9 : end
     每个子进程耗时5s，那么执行完总共需要的是15s。
     但是，这样的代码会导致一个问题，在执行的过程中，可以在另外的tty上输入ps auxf来查看当前的进程状态，会发现类似这样的东东：
root     20531 0.0 0.0 8460 1704 pts/2    S+   21:46   0:00          \_ perl test_proc_1.pl
root     20532 0.0 0.0     0    0 pts/2    Z+   21:46   0:00              \_ [perl] <defunct>
root     20535 0.0 0.0     0    0 pts/2    Z+   21:46   0:00              \_ [perl] <defunct>
root     20536 0.0 0.0     0    0 pts/2    Z+   21:46   0:00              \_ [perl] <defunct>
root     20539 0.0 0.0     0    0 pts/2    Z+   21:46   0:00              \_ [perl] <defunct>
root     20541 0.0 0.0 8460 720 pts/2    S+   21:46   0:00              \_ perl test_proc_1.pl
root     20543 0.0 0.0 8460 720 pts/2    S+   21:46   0:00              \_ perl test_proc_1.pl
root     20545 0.0 0.0 8460 720 pts/2    S+   21:46   0:00              \_ perl test_proc_1.pl
root     20546 0.0 0.0 8460 720 pts/2    S+   21:46   0:00              \_ perl test_proc_1.pl
root     20548 0.0 0.0 8460 720 pts/2    S+   21:46   0:00              \_ perl test_proc_1.pl
     有4个进程，状态为Z，意思就是僵尸进程，而正常的程序，是不应该出现僵尸进程的。
     正常情况下，子进程的退出需要做两件事情，第一，子进程exit，发出一个信号给自己的父进程，第二，父进程对子进程进行回收，如果父进程已经不存在了，那子进程会将init，也就是linux中第一个进程作为自己的父进程，init会代替它的父进程对子进程进行回收。
     我们的情况就是，子进程已经调用了exit，但是父进程并没有对它进行回收，如果父进程持续fork子进程，那僵尸进程就会越来越多，越来越多，最后会导致什么后果，我就不说了。
     父进程回收子进程的函数有两个：
     wait，和waitpid
     wait函数比较简单，没有任何参数，调用以后，父进程会停住，然后等待子进程返回。如果没有子进程，返回-1
     waitpid有两个参数，第一个参数为要等待的子进程的pid值，另外一个是flag，一般来讲，第一个参数为-1，意思就是等待所有的子进程。调用方法如下：
$procid = fork();
if ($procid == 0) {
# == child process ==
print ("this line is printed first\n");
exit(0);
} else {
# == parent process ==
waitpid ($procid, 0);
print ("this line is printed last\n");
}
     其实，最主要的是让父进程知道，什么时候才需要去回收已经退出的子进程，因为父进程也是有很多活需要忙的。
     这个可以通过信号来实现，子进程在退出的时候，会向父进程发送一个信号，我们只要捕获了这个信号，就知道，有些子进程需要回收啦。例子如下：
#!/usr/bin/perl
# test_proc_2.pl
# test multi process
# create by lianming: 2009-08-12
use strict;
use warnings;
use POSIX ":sys_wait_h";
## == number of zombies proc ==
my $zombies = 0;
my $collect;
## == get the child signal ==
$SIG{CHLD} = sub { $zombies++ };

for (my $i = 0; $i < 10; $i ++) {
    ## == fork a new process ==
    my $pid = fork();
    if (!defined($pid)) {
        print "Error in fork: $!";
        exit 1;
    }
    if ($pid == 0) {
        ## == child proc ==
        print "Child $i : My pid = $$\n";
        sleep(5);
        print "Child $i : end\n";
        exit 0;
    }
    ## == if need to collect zombies ==
    if ($zombies > 0) {
        while (($collect = waitpid(-1, WNOHANG)) > 0) {
            $zombies --;
        }
    }
    sleep(1);
}
exit 0;
     执行结果和原先一样：
Child 0 : My pid = 21552
Child 1 : My pid = 21553
Child 2 : My pid = 21554
Child 3 : My pid = 21555
Child 4 : My pid = 21556
Child 0 : end
Child 5 : My pid = 21558
Child 1 : end
Child 6 : My pid = 21570
Child 2 : end
Child 7 : My pid = 21572
Child 3 : end
Child 8 : My pid = 21574
Child 4 : end
Child 9 : My pid = 21575
Child 5 : end
[root@localhost /tmp]
# Child 6 : end
Child 7 : end
Child 8 : end
Child 9 : end
     但是ps auxf的结果就有很大差别了：
root     21551 0.1 0.0 8280 2672 pts/2    S+   22:06   0:00          \_ perl test_proc_2.pl
root     21558 0.0 0.0 8280 1168 pts/2    S+   22:07   0:00              \_ perl test_proc_2.pl
root     21570 0.0 0.0 8280 1168 pts/2    S+   22:07   0:00              \_ perl test_proc_2.pl
root     21572 0.0 0.0 8280 1168 pts/2    S+   22:07   0:00              \_ perl test_proc_2.pl
root     21574 0.0 0.0 8280 1168 pts/2    S+   22:07   0:00              \_ perl test_proc_2.pl
root     21575 0.0 0.0 8280 1168 pts/2    S+   22:07   0:00              \_ perl test_proc_2.pl
    僵尸进程不会存在了。
     $SIG{CHLD} = sub { $zombies++ }; 这条语句，其实就是捕获了子进程退出的时候，向父进程发出的信号，捕获以后，就给一个变量（$zombies）加1。
     如果"$zombies"不为0的时候，那就说明，有子进程退出了，需要进行回收，那父进程就调用waidpid函数，进行一次回收，每回收一个子进程，就给这个变量减去1，这样当"$zombies"减为0的时候，就说明所有的僵尸进程都已经回收了。bingo！
    有的时候，我们只是执行一定量的任务，只管fork就可以了，但是某些时候，我们有太多任务需要执行，要一直持续的fork好多子进程，但是我们希望把子进程的数目控制在一个范围内，比如说，我一个任务，需要有100个子进程来执行，但是我不能100个进程全部fork出去，这样太占用资源了，所以我希望把进程数量控制在10个以内，当第一个进程退出以后，我再fork第11个进程，例子如下：
#!/usr/bin/perl
# test_proc_3.pl
# test multi process
# create by lianming: 2009-08-12
use strict;
use warnings;
use POSIX ":sys_wait_h";
## == number of proc ==
my $num_proc = 0;
## == number of collected ==
my $num_collect = 0;
my $collect;
## == get the child signal ==
$SIG{CHLD} = sub { $num_proc-- };
for (my $i = 0; $i < 10; $i ++) {
    ## == fork a new process ==
    my $pid = fork();
    if (!defined($pid)) {
        print "Error in fork: $!";
        exit 1;
    }
    if ($pid == 0) {
        ## == child proc ==
        print "Child $i : My pid = $$\n";
        sleep(5);
        print "Child $i : end\n";
        exit 0;
    }
    $num_proc ++;
    ## == if need to collect zombies ==
    if (($i-$num_proc-$num_collect) > 0) {
        while (($collect = waitpid(-1, WNOHANG)) > 0) {
            $num_collect ++;
        }
    }
    do {
        sleep(1);
    } until ($num_proc < 3);
}
exit 0;
     执行结果如下：
Child 0 : My pid = 22641
Child 1 : My pid = 22642
Child 2 : My pid = 22643
Child 0 : end
Child 3 : My pid = 22645
Child 1 : end
Child 4 : My pid = 22647
Child 2 : end
Child 5 : My pid = 22658
Child 3 : end
Child 6 : My pid = 22660
Child 4 : end
Child 7 : My pid = 22661
Child 5 : end
Child 8 : My pid = 22663
Child 6 : end
Child 9 : My pid = 22664
Child 7 : end
[root@localhost /tmp]
# Child 8 : end
Child 9 : end
     同时，看到的ps auxf的输出如下：
root     22640 0.0 0.0 8116 2672 pts/2    S+   22:28   0:00          \_ perl test_proc_3.pl
root     22660 0.0 0.0     0    0 pts/2    Z+   22:29   0:00              \_ [perl] <defunct>
root     22661 0.0 0.0 8116 1168 pts/2    S+   22:29   0:00              \_ perl test_proc_3.pl
root     22663 0.0 0.0 8116 1168 pts/2    S+   22:29   0:00              \_ perl test_proc_3.pl
root     22664 0.0 0.0 8116 1168 pts/2    S+   22:29   0:00              \_ perl test_proc_3.pl
     第一个子进程需要5s才能退出，如果1s执行一次fork的话，那么同时应该有5个子进程，但是本例中只有三个，那就是说实现了对进程数量的控制。
     本例中定义了几个变量：
     $num_proc：正在活动的进程数量，控制在3个以内，所以在父进程每次fork完子进程后，都会检查这个变量，如果超出了3个，那就等一会。当父进程fork了新子进程的时候，这个数字会增加，当子进程退出以后，父进程捕获了信号，这个数字会减少。
     $num_collect：已回收的进程数量，每回收一个子进程，变量加一。
     $i：已经fork的进程数量。
     $num_proc和$num_collect的和应该是等于$i的，如果不等于了，那就说明，有子进程需要回收了。
ace_fei
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
perl中创建多进程
weixin_30466421的博客
12-18 226
本次项目中为了提高软件的运行效率，需要对pptx文件进行异步解压，通过运行发现Windows下多进程执行异常（调用fork函数创建子进程）， 调用exe执行奔溃。其他非Windows平台好像没有这个问题。 解决方法： 在Windows下可以使用Win32::Process模块创建子进程，...
Perl 多进程与多线程编程
热门推荐
海云之家
11-09 1万+
PERL 多进程与多线程编程能大大加快程序执行效率（将一个任务分割成若干小任务并行处理）。要进行多进程和多线程编程则分别需要两个模块, fork()和Threads，然而fork（）则为PERL内置函数，因此，只需安装Threads模块（如需变量共享，还需安装Thread::Shared模块）。安装方法如下：     1）Win+R， 打开运行：                    2）在
Perl多进程实战之一
boyishachang的专栏
02-21 421
perl作为一种解释性的语言，很受广大系统管理员的欢迎，好处么就不多说了，坏处也有不少，例如对线程的支持，就一直不咋地，所以大多数情况下，我们都需要多个进程，来帮助我们完成工作，闲话少说，上代码。 #!/usr/bin/perl # test_proc.pl # test multi process # create by  lianming: 2009-08-12 use st
Perl常用模块（Process）
weixin_33810006的博客
06-16 363
2019独角兽企业重金招聘Python工程师标准>>> ...
perl Win32::Process 进程管理
luxiuwen的专栏
02-10 2272
NAME Win32::Process - Create and manipulate processes. SYNOPSIS use Win32::Process;use Win32; sub ErrorReport{    print Win32::FormatMessage( Win32::GetLastError() );} Win32::Process::Create(
基于负载均衡的在线OJ实战项目
最新发布
08-29
4. **多进程架构**：在处理用户请求时，采用多进程模型可以充分利用多核处理器的优势，提高系统的并行处理能力。每个进程可以独立处理一部分请求，通过负载均衡器的调度，保证任务的均匀分配。 5. **数据库设计**：...
Perl在ASIC中的应用
11-17
为了方便在校童鞋们和新加入 ASIC 的同行门快速查阅和学习，把之 前发表的“Perl 在 ASIC 中...多进程等。 实战篇，介绍 Perl 在芯片设计、验证中的应用。 另外，修正了一些笔误，补充部分内容，和增加练习题参考答案。
hlcup：高负荷杯Perl解决方案
02-06
2. **并发处理**：Perl支持多种并发模型，如线程（threads）、进程（forks）以及异步I/O。在高负荷杯比赛中，正确选择并使用并发策略对于提高系统性能至关重要。 3. **优化技巧**：PerlC的使用可以提升代码运行效率...
PERL编程24学时教程
08-30
8. **进程和线程**：探讨Perl中的子进程创建和线程支持，以及多线程编程的基本概念。 9. **网络编程**：学习如何使用Perl进行TCP/IP通信，HTTP请求，以及邮件发送等网络相关的任务。 10. **Web开发**：了解CGI...
GoldenGate企业级运维实战电子书（全套13章）
05-20
这章介绍了GoldenGate在构建高可用性和灾难恢复方案中的角色，包括实时复制、多站点部署和故障切换策略。 第10章：GoldenGate与大数据平台的整合 本章探讨了GoldenGate如何与Hadoop、NoSQL等大数据平台集成，实现...
转：PERL实例精解(第4版) -Win32进程创建
我为编程狂,我为外语狂
04-08 2188
 文章来自：http://book.chinaunix.net/showart.php?id=152518.2.9 Win32进程创建 18.2.9 Win32进程创建在Win32系统上，读者也可以像在UNIX系统上一样使用system函数、exec函数和反引
perl fork()
king_road的专栏
12-10 531
<br />Forking in perl is a nice thing to do, and for some it’s a hard thing to understand. It can be pretty easy to get lost especially since there are 100 ways to the same thing. I’m going to attempt to explain a little bit of the inner workings of
限制perl多进程数量
ace_fei的专栏
07-18 1558
#!/usr/bin/perl use strict; use warnings; use POSIX ":sys_wait_h"; my $maxproc = 4; my $zombies = 0; $SIG{CHLD} = sub { $zombies++ }; for m
perl多进程主进程等子进程结束
xiaocao9903的专栏
09-24 1920
将“use POSIX ":sys_wait_h";”去掉，还有在主进程中打印子进程中的变量是不对的，主进程不知道子进程的状况，除非你用pipe将变量值传给主进程， ################################################## #!/usr/bin/perl #use POSIX ":sys_wait_h"; my $a=10; for($i=1;$i<=3
perl函数说明(fork)
紫轩阁
07-02 4952
fork 这个函数通过调用 fork(2) 系统调用，从一个进程中创建两个进程。如果它成功，该函数给父进程返回新创建的子进程 ID，而给子进程返回 0。如果系统没有足够的资源分配一个新的进程，那么调用失败并返回 undef。文件描述符（以及有时候还有在那些描述符上的锁）是共享的，而所有其他的东西都是拷贝的——或者至少看起来是那样的。 在早于 5.6 版本的 Perl 里，未冲刷的缓冲区在
Perl多进程实例
chinabing的专栏
12-23 451
use strict; use warnings; my @arr_cmd = ("echo child1", "echo child2", "echo child3"); my $child; my @arr_child; foreach(@arr_cmd){ my $cmd = $_; unless($child = fork){ system($cmd); exit;
perl函数应用.doc
03-13
"这篇文档详细介绍了Perl语言中的几个关键函数，包括进程处理相关的函数，如eval、system、fork和pipe，这些在Perl编程中扮演着重要角色。 Perl是一种功能强大的脚本开发语言，尤其适用于文本处理和系统管理任务。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值