Perl多進程實戰之一

尊重原創：http://blog.chinaunix.net/uid-17196076-id-2817715.html

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] 
root     20535  0.0  0.0     0    0 pts/2    Z+   21:46   0:00              \_ [perl] 
root     20536  0.0  0.0     0    0 pts/2    Z+   21:46   0:00              \_ [perl] 
root     20539  0.0  0.0     0    0 pts/2    Z+   21:46   0:00              \_ [perl] 
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] 
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的，如果不等於了，那就說明，有子進程需要回收了。

 

    進程的控制還算簡單吧？

    有的時候，進程和進程之間是需要通訊的，進程不像線程，整個內存空間都是共享的，但是linux也提供了多種進程之間通信的方式，最簡單的方式，就是存在文件裏，下一篇文檔就討論一種文件存儲的方法。