3.自动重启也用到了crontab的日程表，将该文件添加入日程表：
5.pid检测相关函数
启动进程时，pid文件非常重要。不仅可以通过它判断进程是否在运行，还可以从中读取pid号用来杀进程。
PHP也是可以直接进行守护进程的启动与终止的，相对于shell来说会简单很多，理解更方便，当然了PHP守护进程要实现自动重启还是要依赖于shell的crontab日程表，每隔一段时间去执行一次脚本看脚本是否需要重启，如果需要则杀掉进程删除RunFile文件，重新启动并在RunFile文件中写入pid。
注：若您觉得这篇文章还不错请点击下右下角的推荐，有了您的支持才能激发作者更大的写作热情，非常感谢！
本文目录： 1.几个显示函数 2.action函数 3.is_true和is_false函数
4.confir...
crontab -e
#打开日程表，inset模式
*/3 * * * * /usr/bin/php -f process.php
#每3分钟执行一次，放置进程挂掉
4.confirm函数
这个函数一般用不上，因为脚本本来就是为了避免交互式的。在CentOS
7的functions中已经删除了该函数定义语句。不过，借鉴下它的处理方法还是不错的。
以下摘自CentOS 6.6的/etc/init.d/functions文件。
# returns OK if $1 contains $2
strstr() {
[ "${1#*$2*}" = "$1" ] && return 1 # 参数$1中不包含$2时，返回1，否则返回0
return 0
}
# Confirm whether we really want to run this service
confirm() {
[ -x /bin/plymouth ] && /bin/plymouth --hide-splash
while : ; do
echo -n $"Start service $1 (Y)es/(N)o/(C)ontinue? [Y] "
read answer
if strstr $"yY" "$answer" || [ "$answer" = "" ] ; then
return 0
elif strstr $"cC" "$answer" ; then
rm -f /var/run/confirm
[ -x /bin/plymouth ] && /bin/plymouth --show-splash
return 2
elif strstr $"nN" "$answer" ; then
return 1
fi
done
}
第一个函数strstr的作用是判断第一个参数"$1"中是否包含了"$2"，如果包含了则返回状态码0。这函数也是一个不错的技巧。
第二个函数confirm的作用是根据交互式输入的值返回不同的状态码，如果输入的是y或Y或不输入时，返回0。输入的是c或C时，返回状态码2，输入的是n或N时返回状态码1。
于是可以根据confirm的状态值决定是否要继续执行某个程序。
用法和效果如下：
[root@xuexi ~]# confirm
Start service (Y)es/(N)o/(C)ontinue? [Y] Y
[root@xuexi ~]# echo $?
0
[root@xuexi ~]# confirm
Start service (Y)es/(N)o/(C)ontinue? [Y]
[root@xuexi ~]# echo $?
0
[root@xuexi ~]# confirm
Start service (Y)es/(N)o/(C)ontinue? [Y] n
[root@xuexi ~]# echo $?
1
[root@xuexi ~]# confirm
Start service (Y)es/(N)o/(C)ontinue? [Y] c
[root@xuexi ~]# echo $?
2
2.在多次运行该脚本时，会在运行前进行检测，上次执行循环的时间距离现在大于300s或者pid号不匹配都会重启该进程（时间在每次执行循环式都要更新touch）。
6.重头戏(一)：daemon函数
daemon函数用于启动一个程序，并根据结果输出success或failure。
定义语句如下：
# A function to start a program.
daemon() {
# Test syntax.
local gotbase= force= nicelevel corelimit # 定义一大堆变量
local pid base= user= nice= bg= pid_file=
local cgroup=
nicelevel=0
while [ "$1" != "${1##[-+]}" ]; do # 当参数$1以"-"或"+"开头时进入循环，但$1为空时也满足
case $1 in
'') echo $"$0: Usage: daemon [+/-nicelevel] {program}" "[arg1]..."
return 1;;
--check) # daemon接受"--arg value"和"--arg=value"两种格式的参数
base=$2
gotbase="yes"
shift 2
;;
--check=?*)
base=${1#--check=}
gotbase="yes"
shift
;;
--user)
user=$2
shift 2
;;
--user=?*)
user=${1#--user=}
shift
;;
--pidfile)
pid_file=$2
shift 2
;;
--pidfile=?*)
pid_file=${1#--pidfile=}
shift
;;
--force)
force="force"
shift
;;
[-+][0-9]*)
nice="nice -n $1"
shift
;;
*) echo $"$0: Usage: daemon [+/-nicelevel] {program}" "[arg1]..."
return 1;;
esac
done
# Save basename.
[ -z "$gotbase" ] && base=${1##*/} # 若未传递"--check"，则此处获取bashname
# See if it's already running. Look *only* at the pid file.
__pids_var_run "$base" "$pid_file"
[ -n "$pid" -a -z "$force" ] && return # 如进程已在运行(已检测出pid)，且没有使用force
# 强制启动，则退出daemon函数
# make sure it doesn't core dump anywhere unless requested
corelimit="ulimit -S -c ${DAEMON_COREFILE_LIMIT:-0}" # corelimit、cgroup和资源控制有关，忽略它
# if they set NICELEVEL in /etc/sysconfig/foo, honor it
[ -n "${NICELEVEL:-}" ] && nice="nice -n $NICELEVEL"
# if they set CGROUP_DAEMON in /etc/sysconfig/foo, honor it
if [ -n "${CGROUP_DAEMON}" ]; then
if [ ! -x /bin/cgexec ]; then
echo -n "Cgroups not installed"; warning
echo
else
cgroup="/bin/cgexec";
for i in $CGROUP_DAEMON; do
cgroup="$cgroup -g $i";
done
fi
fi
# Echo daemon
[ "${BOOTUP:-}" = "verbose" -a -z "${LSB:-}" ] && echo -n " $base"
# And start it up. # 启动程序。runuser的"-s"指定执行程序的shell，$user指定运行的身份
# "$*"是剔除掉daemon选项后程序的启动指令。
if [ -z "$user" ]; then
$cgroup $nice /bin/bash -c "$corelimit >/dev/null 2>&1 ; $*"
else
$cgroup $nice runuser -s /bin/bash $user -c "$corelimit >/dev/null 2>&1 ; $*"
fi
[ "$?" -eq 0 ] && success $"$base startup" || failure $"$base startup"
}
daemon函数调用方法：
daemon [--check=servicename] [--user=USER] [--pidfile=PIDFILE] [--force] program [prog_args]
需要注意的是：
例如httpd的启动脚本中。
echo -n $"Starting $prog: "
daemon --pidfile=${pidfile} $httpd $OPTIONS
这样的语句的执行结果大致如下：
[[email protected] ~]# service httpd start
Starting httpd: [ OK ]
还需注意，通常program的运行参数可能也是"--"开头的，要和program前面的选项区分。例如：
daemon --pidfile $pidfile --check $servicename $processname --pid-file=$pidfile
第二个"--pid-file"是"$processname"的运行参数，第一个"--pidfile"是daemon检测"$processname"是否已运行的选项。由于提供了"--check
$servicename"，所以函数调用语句__pids_var_run $base [pidfile]中的$base等于$servicename，即表示检查$servicename进程是否允许。如果没有提供该选项，则检查的是$processname。
至此，daemon函数已经分析完成。实际上很简单，就是为daemon提供几个选项，再提供要执行的命令，并为该命令提供启动参数。
PHP写守护进程时要注意几点：
9.2 daemon的使用
daemon：启动一个服务程序。在启动前还检查是否已在运行。
调用方式：
daemon [--check=servicename] [--user=USER] [--pidfile=PIDFILE] [--force] program [prog_args]
"--user"用于指定进程运行身份，"--check"和"--pidfile"用于指定检查进程是否已在运行，"--force"表示即使在运行也同样再启动一个程序。prog_args用于为program程序提供启动参数。
一般daemon会配合以下几个语句同时执行，这正是SysV脚本的一个特点。
echo -n $"Starting $prog: "
daemon --pidfile=${pidfile} $prog $OPTIONS
RETVAL=$?
[ $RETVAL = 0 ] && touch ${lockfile}
return $RETVAL
注意，daemon函数启动程序时，自身就会调用success或failure函数，所以就不需再使用action函数了。如果不使用daemon函数启动服务，通常会配合action函数。例如：
$prog $OPTIONS
RETVAL=$?
[ $RETVAL -eq 0 ] && action "Starting $prog" /bin/true && touch ${lockfile}
1.首先就是函数clearstatcache()函数那里，查官方手册可以知道该函数是清除文件状态缓存的，当在一个脚本中多次检查同一个文件的缓存状态时如果不用该函数就会出错，受该函数影响的有：stat(),
lstat(), file_exists(), is_writable(),is_readable(),
is_executable(), is_file(), is_dir(), is_link(),filectime(),
fileatime(), filemtime(), fileinode(), filegroup(),fileowner(),
filesize(), filetype(), fileperms().
2.action函数
这个函数在写脚本时还比较有用，可以根据退出状态码自动判断是执行success还是执行failure函数。
action函数定义语句如下：
action() {
local STRING rc
STRING=$1
echo -n "$STRING "
shift
"[email protected]" && success $"$STRING" || failure $"$STRING"
rc=$?
echo
return $rc
}
这个函数定义的很有技巧。先将第一个参数保存并踢掉，再执行后面的命令("[email protected]"表示执行后面的命令)。所以，当action函数只有一个参数时，action直接返回OK，状态码为0，当超过一个参数时，第一个参数先被打印，再执行从第二个参数开始的命令。
例如：
[root@xuexi ~]# action
[ OK ]
[root@xuexi ~]# action 5
5 [ OK ]
[root@xuexi ~]# action sleeping sleep 3
sleeping [ OK ]
[root@xuexi ~]# action "moving file" mv xxxxxx.sh aaaaa.sh
moving file mv: cannot stat ‘xxxxxx.sh’: No such file or directory
[FAILED]
所以，在脚本中使用action函数时，可以让命令执行成功与否的判断显得更"专业"。算是一个比较有趣的函数。
通常，该函数会结合/bin/true和/bin/false命令使用，它们无条件返回0或1状态码。
action $"MESSAGES: " /bin/true
action $"MESSAGES: " /bin/false
例如，mysqld启动脚本中，判断mysqld已在运行时，直接输出启动ok的消息。(但实际上根本没做任何事)
if [ $MYSQLDRUNNING = 1 ] && [ $? = 0 ]; then
# already running, do nothing
action $"Starting $prog: " /bin/true
ret=0
这样就基本ok了，要是有具体功能的话还需改动代码。
10.memcached服务启动脚本示例
以下是memcached服务启动脚本的示例，是一个非常简单但却非常通用的Sysv服务启动脚本。
#!/bin/bash
#
# chkconfig: - 86 14
# description: Distributed memory caching daemon
## Default variables
PORT="11211"
USER="nobody"
MAXCONN="1024"
CACHESIZE="64"
OPTIONS=""
RETVAL=0
prog="/usr/local/memcached/bin/memcached"
desc="Distributed memory caching"
lockfile="/var/lock/subsys/memcached"
. /etc/rc.d/init.d/functions
[ -f /etc/sysconfig/memcached ] && source /etc/sysconfig/memcached
start() {
echo -n $"Starting $desc (memcached): "
daemon $prog -d -p $PORT -u $USER -c $MAXCONN -m $CACHESIZE "$OPTIONS"
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch $lockfile
return $RETVAL
}
stop() {
echo -n $"Shutting down $desc (memcached): "
killproc $prog
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f $lockfile
return $RETVAL
}
restart() {
stop
start
}
reload() {
echo -n $"Reloading $desc ($prog): "
killproc $prog -HUP
RETVAL=$?
echo
return $RETVAL
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart)
restart
;;
condrestart)
[ -e $lockfile ] && restart
RETVAL=$?
;;
reload)
reload
;;
status)
status $prog
RETVAL=$?
;;
*)
echo $"Usage: $0 {start|stop|restart|reload|condrestart|status}"
RETVAL=1
esac
exit $RETVAL
回到系列文章大纲：
<?php
function start($file){
$path = dirname(__FILE__).'/';
$runfile = $path.$file.'.run';
$diefile = $path.$file.'.die';
$file = $path."data/{$file}.php";
clearstatcache();
if(file_exists($runfile)){
$oldpid = file_get_contents($runfile);
$nowpid = shell_exec("ps aux | grep 'php -f process.php' | grep ${oldpid} | awk '{print $2}'");
//如果runfile中的pid号可以匹配到正在运行的，并且上次访问runfile的时间和现在相差小于5min则返回
if(($oldpid == $nowpid) && (time() - fileatime($runfile) < 300)){
echo "$file is circle runing no";
return;
}else{
//pid号不匹配或者已经有300秒没有运行循环语句，直接杀掉进程,重新启动
$pid = file_get_contents($runfile);
shell_exec("ps aux | grep 'php -f process.php' | grep {$pid} | xargs --if-no-run-empty kill");
}
}else{
//将文件pid写入run文件
if(!($newpid = getmypid()) || !file_put_contents($runfile,$newpid)){
return;
}
while(true){
//收到结束进程新号，结束进程，并删除相关文件
if(file_exists($diefile) && unlink($runfile) && unlink($diefile)){
return;
}
/*这里是守护进程要做的事*/
file_put_contents($file,"I'm Runing Now".PHP_EOL,FILE_APPEND);
/***********************/
touch($runfile);
sleep(5);
}
}
}
start("test");
8.重头戏(三)：status函数
status函数用于获取进程的运行状态，有以下几种状态：
- ${base} (pid $pid) is running...
- ${base} dead but pid file exists
- ${base} status unknown due to insufficient privileges.
- ${base} dead but subsys locked
- ${base} is stopped
以下的status函数定义语句。注意，此为CentOS 7上语句，比CentOS
6多了一段systemctl的处理，用于Sysv的status状态向systemd的status状态转换。
status() {
local base pid lock_file= pid_file=
# Test syntax.
if [ "$#" = 0 ] ; then
echo $"Usage: status [-p pidfile] {program}"
return 1
fi
if [ "$1" = "-p" ]; then
pid_file=$2 # 指定pidfile
shift 2
fi
if [ "$1" = "-l" ]; then
lock_file=$2 # 指定lockfile
shift 2
fi
base=${1##*/}
if [ "$_use_systemctl" = "1" ]; then
systemctl status ${0##*/}.service
ret=$?
# LSB daemons that dies abnormally in systemd looks alive in
# systemd's eyes due to RemainAfterExit=yes
# lets adjust the reality a little bit
if systemctl show -p ActiveState ${0##*/}.service | grep -q '=active$' && \
systemctl show -p SubState ${0##*/}.service | grep -q '=exited$' ; then
ret=3
fi
return $ret
fi
# First try "pidof"
__pids_var_run "$1" "$pid_file" # 根据给定的pidfile获取program的pid，并返回pid值
RC=$?
if [ -z "$pid_file" -a -z "$pid" ]; then # pid为空，且没有pidfile时，获取program的pid
pid="$(__pids_pidof "$1")"
fi
if [ -n "$pid" ]; then # pid存在，则返回程序正在运行
echo $"${base} (pid $pid) is running..."
return 0
fi
case "$RC" in
0)
echo $"${base} (pid $pid) is running..."
return 0
;;
1) # program进程已死。pid文件存在，但/proc目录下没有对应的文件。
echo $"${base} dead but pid file exists"
return 1
;;
4) # pid文件不可读，错误
echo $"${base} status unknown due to insufficient privileges."
return 4
;;
esac
if [ -z "${lock_file}" ]; then
lock_file=${base}
fi
# See if /var/lock/subsys/${lock_file} exists
if [ -f /var/lock/subsys/${lock_file} ]; then # 检查/var/lock/subsys下是否有lockfile
echo $"${base} dead but subsys locked" # pid不存在，但锁文件存在时
return 2
fi
echo $"${base} is stopped" # 以上都不满足时，表示程序未运行
return 3
}
函数调用方法：
status [-p pidfile] [-l lockfile] program
由于函数定义原因，如果同时提供"-p"和"-l"选项，"-l"选项必须放在"-p"的后面。
5.1 checkpid、__pids_var_run和__pids_pidof函数
以下是函数checkpid、__pids_var_run和__pids_pidof的定义语句。
# Check if any of $pid (could be plural) are running
checkpid() {
local i
for i in $* ; do # 检测/proc目录下是否存在给定的进程目录
[ -d "/proc/$i" ] && return 0
done
return 1
}
# __proc_pids {program} [pidfile]
# Set $pid to pids from /var/run* for {program}. $pid should be declared
# local in the caller.
# Returns LSB exit code for the 'status' action.
__pids_var_run() { # 通过检测pid判断程序是否已在运行
local base=${1##*/} # 获取进程名的basename
local pid_file=${2:-/var/run/$base.pid} # 定义pid文件路径
pid=
if [ -f "$pid_file" ] ; then # 给定的pid文件是否存在
local line p
[ ! -r "$pid_file" ] && return 4 # "user had insufficient privilege"
while : ; do # 将pid文件中的pid值(可能有多行)赋值给pid变量
read line
[ -z "$line" ] && break
for p in $line ; do
[ -z "${p//[0-9]/}" ] && [ -d "/proc/$p" ] && pid="$pid $p"
done
done < "$pid_file"
if [ -n "$pid" ]; then # pid存在，则返回0。否则表示pid文件存在，但/proc下没有对应命令
return 0 # 即进程已死，但pid文件却存在，返回状态码1。
fi
return 1 # "Program is dead and /var/run pid file exists"
fi
return 3 # "Program is not running" # pid文件不存在时，表示进程未运行，返回状态码3
}
# Output PIDs of matching processes, found using pidof
__pids_pidof() { # 下面的pidof命令的意义见稍后解释
pidof -c -m -o $$ -o $PPID -o %PPID -x "$1" || \ # 忽略当前shell的PID，父shell的pid和
# 调用pidof程序的shell的pid
pidof -c -m -o $$ -o $PPID -o %PPID -x "${1##*/}" # 总之就是找出合理的pid
}
从__pidsvar_run函数的定义语句中可以了解到，只有当pid文件存在，且/proc下有pid对应的目录时，才表示进程在运行(当然，线程没有pid文件)。__pids_var_run函数调用方法：
__pids_var_run program [pidfile]
如果不给定pidfile，则默认为/var/run/$base.pid文件。函数的执行结果为4种状态码：
- 0：program正在运行。
- 1：program进程已死。pid文件存在，但/proc目录下没有对应的文件。
- 3：pid文件不存在。
- 4：pid文件的权限错误，不可读。
除了返回状态码，__pids_var_run函数还会保存变量pid的结果，以供其他程序引用。
__pids_pidof中使用了pidof命令，其中使用了几个"-o"选项，它用于忽略指定的pid。但看上去"$$""$PPID""%PPID"不是很好理解。"-o
$$"是忽略的是shell进程，大多数时候它会继承父shell的pid，但在脚本中时它代表的是脚本所在shell的pid。"-o
$PPID"忽略的是父shell。"-o
%PPID"忽略的是调用pidof命令的shell。不是很好理解，可以参考下面的测试语句。
测试脚本：
#!/bin/bash
echo 'pidof bash: '`pidof bash`
echo 'script shell pid: '`echo $$`
echo 'script parent shell pid: '`echo $PPID`
echo 'pidof -o $$ bash: '`pidof -o $$ bash`
echo 'pidof -o $PPID bash: '`pidof -o $PPID bash`
echo 'pidof -o %PPID bash: '`pidof -o %PPID bash`
echo 'pidof -o $$ -o $PPID -o %PPID bash: '`pidof -o $$ -o $PPID -o %PPID bash`
测试语句：
[root@xuexi ~]# pidof bash
3306 2436 2302
[root@xuexi ~]# (echo 'parent shell: '$$;echo "current bash pid: `pidof bash`";./test.sh)|cat -n
1 parent shell: 2302
2 current bash pid: 3745 3306 2436 2302
3 pidof bash: 3748 3745 3306 2436 2302
4 script shell pid: 3748
5 script parent shell pid: 3745
6 pidof -o $$ bash: 3745 3306 2436 2302
7 pidof -o $PPID bash: 3748 3306 2436 2302
8 pidof -o %PPID bash: 3745 3306 2436 2302
9 pidof -o $$ -o $PPID -o %PPID bash: 3306 2436 2302
第一个pidof命令：说明当前已有3个bash，pid为：3306、2436和2302。
第二个命令：
- 行1说明括号的父shell为2302。
- 行5说明脚本的父shell为3745。即括号的父shell为当前bash环境，脚本的父shell为括号所在shell。
- 行2减第一个命令的结果说明括号所在子shell的pid为3745。
- 行3减行2说明shell脚本所在子shell的pid为3748。
- "-o
$$"忽略的是当前shell，即脚本所在shell的pid，因为在shell脚本中时，$$不继承父shell的pid。 - "-o $PPID"忽略的是pidof所在父shell，即括号所在shell。
- "-o %PPID"忽略的是调用调用pidof程序所在的shell，即脚本所在shell。
9.3 killproc的使用
killproc：杀掉给定的服务进程。
函数调用方式：
killproc [-p pidfile] [-d delay] program [-signal]
"-p
pidfile"：选项用于指定从此文件中获取进程的pid号，不指定时默认从/var/run/$base.pid中获取。
"-signal"：用于指定kill发送的信号。如果不指定，则默认先发送TERM信号，在"-d
delay"时间段内仍不断检测是否进程已经被杀死，如果还未死透，则delay超时后发送KILL信号强制杀死。
"-d
delay"：指定未使用"-signal"时的延迟检测时间。有效单位为秒、分、时、日("smhd")，不写时默认为秒。
需要明确的是，只有/proc目录下没有了pid对应的目录才算是杀死了。
一般来说，killproc前会判断进程是否已在运行，最后还要删除pid文件和lock文件。当然，killproc函数可以保证pid文件被删除。所以，killproc函数大致会同时配合以下语句用来杀进程：
status -p ${pidfile} $prog > /dev/null
if [[ $? = 0 ]]; then
echo -n $"Stopping $prog: "
killproc -p ${pidfile} -d ${STOP_TIMEOUT} $httpd
else
echo -n $"Stopping $prog: "
success
fi
RETVAL=$?
[ $RETVAL -eq 0 ] && rm -f ${lockfile} ${pidfile}
同样注意，killproc中已经自带success和failure函数。如果不使用killproc杀进程，则通常会配合action函数或者success、failure。大致如下：
killall $prog ； usleep 50000 ； killall $prog
RETVAL=$?
if [ "RETVAL" -ne 0 ];then
action $"Stopping $prog: " /bin/true
rm -rf ${lockfile} ${pidfile}
else
action $"Stoping $prog: " /bin/false
fi
以上由于采用的是killall命令，如果采用的是kill命令，则需要先获取进程的pid，在此之前还要检查pid文件是否存在。
转载本站文章请注明出处：vns威尼斯城官网登入 http://www.tiec-ccpittj.com/?p=5411