php写守护进程（Daemon）

 守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。php也可以实现守护进程的功能。

 

1、基本概念

    进程

            每个进程都有一个父进程，子进程退出，父进程能得到子进程退出的状态。

    进程组

            每个进程都属于一个进程组，每个进程组都有一个进程组号，该号等于该进程组组长的PID

2、守护编程要点

    1. 在后台运行。     
         为避免挂起控制终端将Daemon放入后台执行。方法是在进程中调用fork使父进程终止，让Daemon在子进程中后台执行。 if($pid=pcntl_fork()) exit(0);//是父进程，结束父进程，子进程继续
    2. 脱离控制终端，登录会话和进程组 
       有必要先介绍一下Linux中的进程与控制终端，登录会话和进程组之间的关系：进程属于一个进程组，进程组号（GID）就是进程组长的进程号（PID）。登录会话可以包含多个进程组。这些进程组共享一个控制终端。这个控制终端通常是创建进程的登录终  端。 控制终端，登录会话和进程组通常是从父进程继承下来的。我们的目的就是要摆脱它们，使之不受它们的影响。方法是在第1点的基础上，调用setsid()使进程成为会话组长： posix_setsid();
        说明：当进程是会话组长时setsid()调用失败。但第一点已经保证进程不是会话组长。setsid()调用成功后，进程成为新的会话组长和新的进程组长，并与原来的登录会话和进程组脱离。由于会话过程对控制终端的独占性，进程同时与控制终端脱离。
    3. 禁止进程重新打开控制终端
        现在，进程已经成为无终端的会话组长。但它可以重新申请打开一个控制终端。可以通过使进程不再成为会话组长来禁止进程重新打开控制终端： if($pid=pcntl_fork()) exit(0);//结束第一子进程，第二子进程继续（第二子进程不再是会话组长）
    4. 关闭打开的文件描述符
        进程从创建它的父进程那里继承了打开的文件描述符。如不关闭，将会浪费系统资源，造成进程所在的文件系统无法卸下以及引起无法预料的错误。按如下方法关闭它们：
        fclose(STDIN),fclose(STDOUT),fclose(STDERR)关闭标准输入输出与错误显示。
    5. 改变当前工作目录
        进程活动时，其工作目录所在的文件系统不能卸下。一般需要将工作目录改变到根目录。对于需要转储核心，写运行日志的进程将工作目录改变到特定目录如chdir("/")
    6. 重设文件创建掩模
        进程从创建它的父进程那里继承了文件创建掩模。它可能修改守护进程所创建的文件的存取位。为防止这一点，将文件创建掩模清除：umask(0);
    7. 处理SIGCHLD信号
        处理SIGCHLD信号并不是必须的。但对于某些进程，特别是服务器进程往往在请求到来时生成子进程处理请求。如果父进程不等待子进程结束，子进程将成为僵尸进程（zombie）从而占用系统资源。如果父进程等待子进程结束，将增加父进程的负担，影  响服务器进程的并发性能。在Linux下可以简单地将SIGCHLD信号的操作设为SIG_IGN。 signal(SIGCHLD,SIG_IGN);
        这样，内核在子进程结束时不会产生僵尸进程。这一点与BSD4不同，BSD4下必须显式等待子进程结束才能释放僵尸进程。关于信号的问题请参考Linux 信号说明列表

  

3、实例

[php]  view plain  copy

 print ?

1. <?php  
2. /** 
3. *@author tengzhaorong@gmail.com 
4. *@date 2013-07-25 
5. * 后台脚本控制类 
6. */  
7. class DaemonCommand{  
8.    
9.     private $info_dir="/tmp";  
10.     private $pid_file="";  
11.     private $terminate=false; //是否中断  
12.     private $workers_count=0;  
13.     private $gc_enabled=null;  
14.     private $workers_max=8; //最多运行8个进程  
15.    
16.     public function __construct($is_sington=false,$user='nobody',$output="/dev/null"){  
17.    
18.             $this->is_sington=$is_sington; //是否单例运行，单例运行会在tmp目录下建立一个唯一的PID  
19.             $this->user=$user;//设置运行的用户 默认情况下nobody  
20.             $this->output=$output; //设置输出的地方  
21.             $this->checkPcntl();  
22.     }  
23.     //检查环境是否支持pcntl支持  
24.     public function checkPcntl(){  
25.         if ( ! function_exists('pcntl_signal_dispatch')) {  
26.             // PHP < 5.3 uses ticks to handle signals instead of pcntl_signal_dispatch  
27.             // call sighandler only every 10 ticks  
28.             declare(ticks = 10);  
29.         }  
30.    
31.         // Make sure PHP has support for pcntl  
32.         if ( ! function_exists('pcntl_signal')) {  
33.             $message = 'PHP does not appear to be compiled with the PCNTL extension.  This is neccesary for daemonization';  
34.             $this->_log($message);  
35.             throw new Exception($message);  
36.         }  
37.         //信号处理  
38.         pcntl_signal(SIGTERM, array(__CLASS__, "signalHandler"),false);  
39.         pcntl_signal(SIGINT, array(__CLASS__, "signalHandler"),false);  
40.         pcntl_signal(SIGQUIT, array(__CLASS__, "signalHandler"),false);  
41.    
42.         // Enable PHP 5.3 garbage collection  
43.         if (function_exists('gc_enable'))  
44.         {  
45.             gc_enable();  
46.             $this->gc_enabled = gc_enabled();  
47.         }  
48.     }  
49.    
50.     // daemon化程序  
51.     public function daemonize(){  
52.    
53.         global $stdin, $stdout, $stderr;  
54.         global $argv;  
55.    
56.         set_time_limit(0);  
57.    
58.         // 只允许在cli下面运行  
59.         if (php_sapi_name() != "cli"){  
60.             die("only run in command line mode\n");  
61.         }  
62.    
63.         // 只能单例运行  
64.         if ($this->is_sington==true){  
65.    
66.             $this->pid_file = $this->info_dir . "/" .__CLASS__ . "_" . substr(basename($argv[0]), 0, -4) . ".pid";  
67.             $this->checkPidfile();  
68.         }  
69.    
70.         umask(0); //把文件掩码清0  
71.    
72.         if (pcntl_fork() != 0){ //是父进程，父进程退出  
73.             exit();  
74.         }  
75.    
76.         posix_setsid();//设置新会话组长，脱离终端  
77.    
78.         if (pcntl_fork() != 0){ //是第一子进程，结束第一子进程     
79.             exit();  
80.         }  
81.    
82.         chdir("/"); //改变工作目录  
83.    
84.         $this->setUser($this->user) or die("cannot change owner");  
85.    
86.         //关闭打开的文件描述符  
87.         fclose(STDIN);  
88.         fclose(STDOUT);  
89.         fclose(STDERR);  
90.    
91.         $stdin  = fopen($this->output, 'r');  
92.         $stdout = fopen($this->output, 'a');  
93.         $stderr = fopen($this->output, 'a');  
94.    
95.         if ($this->is_sington==true){  
96.             $this->createPidfile();  
97.         }  
98.    
99.     }  
100.     //--检测pid是否已经存在  
101.     public function checkPidfile(){  
102.    
103.         if (!file_exists($this->pid_file)){  
104.             return true;  
105.         }  
106.         $pid = file_get_contents($this->pid_file);  
107.         $pid = intval($pid);  
108.         if ($pid > 0 && posix_kill($pid, 0)){  
109.             $this->_log("the daemon process is already started");  
110.         }  
111.         else {  
112.             $this->_log("the daemon proces end abnormally, please check pidfile " . $this->pid_file);  
113.         }  
114.         exit(1);  
115.    
116.     }  
117.     //----创建pid  
118.     public function createPidfile(){  
119.    
120.         if (!is_dir($this->info_dir)){  
121.             mkdir($this->info_dir);  
122.         }  
123.         $fp = fopen($this->pid_file, 'w') or die("cannot create pid file");  
124.         fwrite($fp, posix_getpid());  
125.         fclose($fp);  
126.         $this->_log("create pid file " . $this->pid_file);  
127.     }  
128.    
129.     //设置运行的用户  
130.     public function setUser($name){  
131.    
132.         $result = false;  
133.         if (empty($name)){  
134.             return true;  
135.         }  
136.         $user = posix_getpwnam($name);  
137.         if ($user) {  
138.             $uid = $user['uid'];  
139.             $gid = $user['gid'];  
140.             $result = posix_setuid($uid);  
141.             posix_setgid($gid);  
142.         }  
143.         return $result;  
144.    
145.     }  
146.     //信号处理函数  
147.     public function signalHandler($signo){  
148.    
149.         switch($signo){  
150.    
151.             //用户自定义信号  
152.             case SIGUSR1: //busy  
153.             if ($this->workers_count < $this->workers_max){  
154.                 $pid = pcntl_fork();  
155.                 if ($pid > 0){  
156.                     $this->workers_count ++;  
157.                 }  
158.             }  
159.             break;  
160.             //子进程结束信号  
161.             case SIGCHLD:  
162.                 while(($pid=pcntl_waitpid(-1, $status, WNOHANG)) > 0){  
163.                     $this->workers_count --;  
164.                 }  
165.             break;  
166.             //中断进程  
167.             case SIGTERM:  
168.             case SIGHUP:  
169.             case SIGQUIT:  
170.    
171.                 $this->terminate = true;  
172.             break;  
173.             default:  
174.             return false;  
175.         }  
176.    
177.     }  
178.     /** 
179.     *开始开启进程 
180.     *$count 准备开启的进程数 
181.     */  
182.     public function start($count=1){  
183.    
184.         $this->_log("daemon process is running now");  
185.         pcntl_signal(SIGCHLD, array(__CLASS__, "signalHandler"),false); // if worker die, minus children num  
186.         while (true) {  
187.             if (function_exists('pcntl_signal_dispatch')){  
188.    
189.                 pcntl_signal_dispatch();  
190.             }  
191.    
192.             if ($this->terminate){  
193.                 break;  
194.             }  
195.             $pid=-1;  
196.             if($this->workers_count<$count){  
197.    
198.                 $pid=pcntl_fork();  
199.             }  
200.    
201.             if($pid>0){  
202.    
203.                 $this->workers_count++;  
204.    
205.             }elseif($pid==0){  
206.    
207.                 // 这个符号表示恢复系统对信号的默认处理  
208.                 pcntl_signal(SIGTERM, SIG_DFL);  
209.                 pcntl_signal(SIGCHLD, SIG_DFL);  
210.                 if(!empty($this->jobs)){  
211.                     while($this->jobs['runtime']){  
212.                         if(empty($this->jobs['argv'])){  
213.                             call_user_func($this->jobs['function'],$this->jobs['argv']);  
214.                         }else{  
215.                             call_user_func($this->jobs['function']);  
216.                         }  
217.                         $this->jobs['runtime']--;  
218.                         sleep(2);  
219.                     }  
220.                     exit();  
221.    
222.                 }  
223.                 return;  
224.    
225.             }else{  
226.    
227.                 sleep(2);  
228.             }  
229.    
230.    
231.         }  
232.    
233.         $this->mainQuit();  
234.         exit(0);  
235.    
236.     }  
237.    
238.     //整个进程退出  
239.     public function mainQuit(){  
240.    
241.         if (file_exists($this->pid_file)){  
242.             unlink($this->pid_file);  
243.             $this->_log("delete pid file " . $this->pid_file);  
244.         }  
245.         $this->_log("daemon process exit now");  
246.         posix_kill(0, SIGKILL);  
247.         exit(0);  
248.     }  
249.    
250.     // 添加工作实例，目前只支持单个job工作  
251.     public function setJobs($jobs=array()){  
252.    
253.         if(!isset($jobs['argv'])||empty($jobs['argv'])){  
254.    
255.             $jobs['argv']="";  
256.    
257.         }  
258.         if(!isset($jobs['runtime'])||empty($jobs['runtime'])){  
259.    
260.             $jobs['runtime']=1;  
261.    
262.         }  
263.    
264.         if(!isset($jobs['function'])||empty($jobs['function'])){  
265.    
266.             $this->log("你必须添加运行的函数！");  
267.         }  
268.    
269.         $this->jobs=$jobs;  
270.    
271.     }  
272.     //日志处理  
273.     private  function _log($message){  
274.         printf("%s\t%d\t%d\t%s\n", date("c"), posix_getpid(), posix_getppid(), $message);  
275.     }  
276.    
277. }  
278.    
279. //调用方法1  
280. $daemon=new DaemonCommand(true);  
281. $daemon->daemonize();  
282. $daemon->start(2);//开启2个子进程工作  
283. work();  
284.    
285.    
286.    
287.    
288. //调用方法2  
289. $daemon=new DaemonCommand(true);  
290. $daemon->daemonize();  
291. $daemon->addJobs(array('function'=>'work','argv'=>'','runtime'=>1000));//function 要运行的函数,argv运行函数的参数，runtime运行的次数  
292. $daemon->start(2);//开启2个子进程工作  
293.    
294. //具体功能的实现  
295. function work(){  
296.       echo "测试1";  
297. }  
298. ?>