Perl多進程

時間  2019-12-14
標籤 perl 進程 欄目 Perl 简体版
原文   原文鏈接

perl做爲一種解釋性的語言，很是受廣大系統管理員的歡迎，優勢麼就很少說了，壞處也有很多，好比對線程的支持，就一直不咋地，因此大多數狀況下，咱們都需要多個進程，來幫助咱們完畢工做，閒話少說，上代碼。linux

  1. #!/usr/bin/perl
  2. # test_proc.pl
  3. # test multi process
  4. # create by lianming: 2009-08-12
  5. use strict;
  6. use warnings;
  7. ## == fork a new process ==
  8. my  $pid =  fork ( );
  9. if  ( ! defined ( $pid ) )  {
  10.      print  "Error in fork: $!";
  11.      exit  1;
  12. }
  13. if  ( $pid ==  0 )  {
  14.      ## == child proc ==
  15.      print  "Child: My pid = $$\n";
  16.      sleep ( 5 );
  17.      print  "Child: end\n";
  18.      exit  0;
  19. }  else  {
  20.      ## == parent proc ==
  21.      print  "Parent My pid = $$, and my child's pid = $pid\n";
  22.      sleep ( 5 );
  23.      print  "Parent: end\n";
  24. }
  25. 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值的不一樣，來分三種狀況了。
一、fork失敗的狀況：這個時候，$pid處於沒有定義的狀態，上例中作的一個"if (!defined($pid))"的推斷，假設爲真，說明$pid沒有定義，fork失敗，這個時候就要打印錯誤信息，並且退出。
二、子進程：假設是子進程，那麼$pid的值爲0，就是上例中"if ($pid == 0)"條件爲真的情況，在"$pid == 0"的時候，那就都是子進程了，上例中，子進程將本身的pid打出來，爲19481。
三、父進程：假設是父進程，那麼$pid的值爲它派生出的子進程的pid，也就是不爲0，就是else的狀況，上例中把$pid打出來，可以看到，也是 19481，就是子進程的pid值。
這僅僅是一個最簡單的樣例，一個父進程派生一個子進程，再略微複雜一點，一個父進程派生多個子進程，代碼例如如下：函數

  1. #!/usr/bin/perl
  2. # test_proc_1.pl
  3. # test multi process
  4. # create by lianming: 2009-08-12
  5. use strict;
  6. use warnings;
  7.  
  8. for  ( my  $i =  0;  $i  <  10;  $i ++ )  {
  9.      ## == fork a new process ==
  10.      my  $pid =  fork ( );
  11.      if  ( ! defined ( $pid ) )  {
  12.          print  "Error in fork: $!";
  13.          exit  1;
  14.      }
  15.      if  ( $pid ==  0 )  {
  16.          ## == child proc ==
  17.          print  "Child $i : My pid = $$\n";
  18.          sleep ( 5 );
  19.          print  "Child $i : end\n";
  20.          exit  0;
  21.      }
  22.      sleep ( 1 );
  23. }
  24. 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，意思就是等待所有的子進程。調用方法例如如下：this

  1. $procid =  fork ( );
  2. if  ( $procid ==  0 )  {
  3. # == child process ==
  4. print  ( "this line is printed first\n" );
  5. exit ( 0 );
  6. }  else  {
  7. # == parent process ==
  8. waitpid  ( $procid,  0 );
  9. print  ( "this line is printed last\n" );
  10. }

事實上，最基本的是讓父進程知道，何時才需要去回收已經退出的子進程，因爲父進程也是有很是多活需要忙的。
這個可以經過信號來實現，子進程在退出的時候，會向父進程發送一個信號，咱們僅僅要捕獲了這個信號，就知道，有些子進程需要回收啦。樣例例如如下：spa

  1. #!/usr/bin/perl
  2. # test_proc_2.pl
  3. # test multi process
  4. # create by lianming: 2009-08-12
  5. use strict;
  6. use warnings;
  7. use POSIX  ":sys_wait_h";
  8. ## == number of zombies proc ==
  9. my  $zombies =  0;
  10. my  $collect;
  11. ## == get the child signal ==
  12. $SIG {CHLD } =  sub  {  $zombies++  };
  13.  
  14. for  ( my  $i =  0;  $i  <  10;  $i ++ )  {
  15.      ## == fork a new process ==
  16.      my  $pid =  fork ( );
  17.      if  ( ! defined ( $pid ) )  {
  18.          print  "Error in fork: $!";
  19.          exit  1;
  20.      }
  21.      if  ( $pid ==  0 )  {
  22.          ## == child proc ==
  23.          print  "Child $i : My pid = $$\n";
  24.          sleep ( 5 );
  25.          print  "Child $i : end\n";
  26.          exit  0;
  27.      }
  28.      ## == if need to collect zombies ==
  29.      if  ( $zombies  >  0 )  {
  30.          while  ( ( $collect =  waitpid ( -1, WNOHANG ) )  >  0 )  {
  31.              $zombies --;
  32.          }
  33.      }
  34.      sleep ( 1 );
  35. }
  36. 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個進程，樣例例如如下：線程

  1. #!/usr/bin/perl
  2. # test_proc_3.pl
  3. # test multi process
  4. # create by lianming: 2009-08-12
  5. use strict;
  6. use warnings;
  7. use POSIX  ":sys_wait_h";
  8. ## == number of proc ==
  9. my  $num_proc =  0;
  10. ## == number of collected ==
  11. my  $num_collect =  0;
  12. my  $collect;
  13. ## == get the child signal ==
  14. $SIG {CHLD } =  sub  {  $num_proc--  };
  15. for  ( my  $i =  0;  $i  <  10;  $i ++ )  {
  16.      ## == fork a new process ==
  17.      my  $pid =  fork ( );
  18.      if  ( ! defined ( $pid ) )  {
  19.          print  "Error in fork: $!";
  20.          exit  1;
  21.      }
  22.      if  ( $pid ==  0 )  {
  23.          ## == child proc ==
  24.          print  "Child $i : My pid = $$\n";
  25.          sleep ( 5 );
  26.          print  "Child $i : end\n";
  27.          exit  0;
  28.      }
  29.      $num_proc ++;
  30.      ## == if need to collect zombies ==
  31.      if  ( ( $i- $num_proc- $num_collect )  >  0 )  {
  32.          while  ( ( $collect =  waitpid ( -1, WNOHANG ) )  >  0 )  {
  33.              $num_collect ++;
  34.          }
  35.      }
  36.      do  {
  37.          sleep ( 1 );
  38.      }  until  ( $num_proc  <  3 );
  39. }
  40. 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的，假設不等於了，那就說明，有子進程需要回收了。進程

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程