我有一个python守护程序作为我的web应用程序的一部分运行/如果我的守护程序正在运行，我如何快速检查（使用python），如果没有，启动它？
我想以这种方式修复守护进程的任何崩溃，因此脚本不必手动运行，它会在调用后立即自动运行，然后继续运行。
如果我的脚本正在运行，我如何检查（使用python）？
答案 0 :(得分：137)
在Linux系统上使用的技术是使用域套接字：
import socket
import sys
import time
def get_lock(process_name):
# Without holding a reference to our socket somewhere it gets garbage
# collected when the function exits
get_lock._lock_socket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
try:
get_lock._lock_socket.bind('\0' + process_name)
print 'I got the lock'
except socket.error:
print 'lock exists'
sys.exit()
get_lock('running_test')
while True:
time.sleep(3)
它是原子的并且避免了如果您的进程被发送了SIGKILL而存在锁定文件的问题
您可以read in the documentation for socket.close收集垃圾时自动关闭套接字。
答案 1 :(得分：85)
在某处删除一个pid文件（例如/ tmp）。然后，您可以通过检查文件中的PID是否存在来检查进程是否正在运行。不要忘记在干净地关闭时删除文件，并在启动时检查它。
#/usr/bin/env python
import os
import sys
pid = str(os.getpid())
pidfile = "/tmp/mydaemon.pid"
if os.path.isfile(pidfile):
print "%s already exists, exiting" % pidfile
sys.exit()
file(pidfile, 'w').write(pid)
try:
# Do some actual work here
finally:
os.unlink(pidfile)
然后，您可以通过检查/tmp/mydaemon.pid的内容是否是现有进程来检查进程是否正在运行。 Monit（上面提到）可以为你做这个，或者你可以编写一个简单的shell脚本来使用ps的返回代码为你检查。
ps up `cat /tmp/mydaemon.pid ` >/dev/null && echo "Running" || echo "Not running"
为了额外的功劳，您可以使用atexit模块来确保您的程序在任何情况下（在被杀死，引发异常等情况下）清理其pid文件。
答案 2 :(得分：16)
答案 3 :(得分：10)
在UNIX上有很好的重启进程包。有一个关于构建和配置它的精彩教程的是monit。通过一些调整，您可以拥有坚实可靠的技术来保持您的守护进程。
答案 4 :(得分：10)
当然Dan的例子不会像它应该的那样有用。
的确，如果脚本崩溃，引发异常，或者不清除pid文件，脚本将会多次运行。
我建议以下来自另一个网站：
这是为了检查是否已存在锁定文件
\#/usr/bin/env python
import os
import sys
if os.access(os.path.expanduser("~/.lockfile.vestibular.lock"), os.F_OK):
#if the lockfile is already there then check the PID number
#in the lock file
pidfile = open(os.path.expanduser("~/.lockfile.vestibular.lock"), "r")
pidfile.seek(0)
old_pid = pidfile.readline()
# Now we check the PID from lock file matches to the current
# process PID
if os.path.exists("/proc/%s" % old_pid):
print "You already have an instance of the program running"
print "It is running as process %s," % old_pid
sys.exit(1)
else:
print "File is there but the program is not running"
print "Removing lock file for the: %s as it can be there because of the program last time it was run" % old_pid
os.remove(os.path.expanduser("~/.lockfile.vestibular.lock"))
这是我们将PID文件放入锁定文件
的代码的一部分pidfile = open(os.path.expanduser("~/.lockfile.vestibular.lock"), "w")
pidfile.write("%s" % os.getpid())
pidfile.close()
此代码将检查pid的值与现有运行进程的比较。避免双重执行。
我希望它会有所帮助。
答案 5 :(得分：4)
有无数的选择。一种方法是使用系统调用或python库为您执行此类调用。另一个只是产生一个像：
这样的过程ps ax | grep processName
并解析输出。很多人选择这种方法，在我看来并不一定是坏方法。
答案 6 :(得分：3)
试试这个其他版本
def checkPidRunning(pid):
'''Check For the existence of a unix pid.
'''
try:
os.kill(pid, 0)
except OSError:
return False
else:
return True
# Entry point
if __name__ == '__main__':
pid = str(os.getpid())
pidfile = os.path.join("/", "tmp", __program__+".pid")
if os.path.isfile(pidfile) and checkPidRunning(int(file(pidfile,'r').readlines()[0])):
print "%s already exists, exiting" % pidfile
sys.exit()
else:
file(pidfile, 'w').write(pid)
# Do some actual work here
main()
os.unlink(pidfile)
答案 7 :(得分：2)
我是管理守护进程的Supervisor的忠实粉丝。它是用Python编写的，因此有很多关于如何与Python交互或扩展它的示例。为了您的目的，XML-RPC process control API应该很好地工作。
答案 8 :(得分：2)
我的解决方案是检查进程和命令行参数 在Windows和ubuntu linux上测试
import psutil
import os
def is_running(script):
for q in psutil.process_iter():
if q.name().startswith('python'):
if len(q.cmdline())>1 and script in q.cmdline()[1] and q.pid !=os.getpid():
print("'{}' Process is already running".format(script))
return True
return False
if not is_running("test.py"):
n = input("What is Your Name? ")
print ("Hello " + n)
答案 9 :(得分：1)
遇到这个老问题，我自己在寻找解决方案。
使用psutil：
import psutil
import sys
from subprocess import Popen
for process in psutil.process_iter():
if process.cmdline() == ['python', 'your_script.py']:
sys.exit('Process found: exiting.')
print('Process not found: starting it.')
Popen(['python', 'your_script.py'])
答案 10 :(得分：0)
我一直在寻找有关此问题的答案，在我看来，我想到了一个非常简单且非常好的解决方案（因为我猜不可能对此存在误报 - 时间戳如何如果程序不这样做，则更新 TXT 上的内容）：
--> 根据您的需要，在某个时间间隔内继续在 TXT 上写入当前时间戳（这里每半小时是完美的）。
如果您检查时 TXT 上的时间戳相对于当前时间戳已经过时，则说明程序存在问题，应该重新启动它或您更喜欢做什么。
答案 11 :(得分：0)
如果您只是在寻找流程名称，那么这是一个简单的例子：
import os
def pname_exists(inp):
os.system('ps -ef > /tmp/psef')
lines=open('/tmp/psef', 'r').read().split('\n')
res=[i for i in lines if inp in i]
return True if res else False
Result:
In [21]: pname_exists('syslog')
Out[21]: True
In [22]: pname_exists('syslog_')
Out[22]: False
答案 12 :(得分：0)
这是更有用的代码（检查python是否正好执行脚本）：
#! /usr/bin/env python
import os
from sys import exit
def checkPidRunning(pid):
global script_name
if pid<1:
print "Incorrect pid number!"
exit()
try:
os.kill(pid, 0)
except OSError:
print "Abnormal termination of previous process."
return False
else:
ps_command = "ps -o command= %s | grep -Eq 'python .*/%s'" % (pid,script_name)
process_exist = os.system(ps_command)
if process_exist == 0:
return True
else:
print "Process with pid %s is not a Python process. Continue..." % pid
return False
if __name__ == '__main__':
script_name = os.path.basename(__file__)
pid = str(os.getpid())
pidfile = os.path.join("/", "tmp/", script_name+".pid")
if os.path.isfile(pidfile):
print "Warning! Pid file %s existing. Checking for process..." % pidfile
r_pid = int(file(pidfile,'r').readlines()[0])
if checkPidRunning(r_pid):
print "Python process with pid = %s is already running. Exit!" % r_pid
exit()
else:
file(pidfile, 'w').write(pid)
else:
file(pidfile, 'w').write(pid)
# main programm
....
....
os.unlink(pidfile)
这是字符串：
ps_command = "ps -o command= %s | grep -Eq 'python .*/%s'" % (pid,script_name)
返回0，并且当前正在运行“python”进程，并将脚本名称作为参数运行。
答案 13 :(得分：0)
试试这个：
#/usr/bin/env python
import os, sys, atexit
try:
# Set PID file
def set_pid_file():
pid = str(os.getpid())
f = open('myCode.pid', 'w')
f.write(pid)
f.close()
def goodby():
pid = str('myCode.pid')
os.remove(pid)
atexit.register(goodby)
set_pid_file()
# Place your code here
except KeyboardInterrupt:
sys.exit(0)
答案 14 :(得分：0)
不要开发自己的PID文件解决方案（它有比你想象的更多细微之处和极端情况），请看supervisord - 这是一个过程控制系统，可以轻松地包装作业控制和现有Python脚本周围的守护进程行为。
答案 15 :(得分：0)
ps ax | grep processName
如果pycharm中的调试脚本总是退出
pydevd.py --multiproc --client 127.0.0.1 --port 33882 --file processName
答案 16 :(得分：0)
其他答案非常适合像cron作业这样的事情，但如果您正在运行守护程序，则应使用daemontools之类的内容监控它。
答案 17 :(得分：-1)
使用bash查找具有当前脚本名称的进程。没有额外的文件。
import commands
import os
import time
import sys
def stop_if_already_running():
script_name = os.path.basename(__file__)
l = commands.getstatusoutput("ps aux | grep -e '%s' | grep -v grep | awk '{print $2}'| awk '{print $2}'" % script_name)
if l[1]:
sys.exit(0);
要测试，请添加
stop_if_already_running()
print "running normally"
while True:
time.sleep(3)
答案 18 :(得分：-1)
请考虑以下示例来解决您的问题：
#!/usr/bin/python
# -*- coding: latin-1 -*-
import os, sys, time, signal
def termination_handler (signum,frame):
global running
global pidfile
print 'You have requested to terminate the application...'
sys.stdout.flush()
running = 0
os.unlink(pidfile)
running = 1
signal.signal(signal.SIGINT,termination_handler)
pid = str(os.getpid())
pidfile = '/tmp/'+os.path.basename(__file__).split('.')[0]+'.pid'
if os.path.isfile(pidfile):
print "%s already exists, exiting" % pidfile
sys.exit()
else:
file(pidfile, 'w').write(pid)
# Do some actual work here
while running:
time.sleep(10)
我建议使用此脚本，因为它只能执行一次。
答案 19 :(得分：-1)
这是我在Linux中用来避免启动已经运行的脚本的方法：
import os
import sys
script_name = os.path.basename(__file__)
pidfile = os.path.join("/tmp", os.path.splitext(script_name)[0]) + ".pid"
def create_pidfile():
if os.path.exists(pidfile):
with open(pidfile, "r") as _file:
last_pid = int(_file.read())
# Checking if process is still running
last_process_cmdline = "/proc/%d/cmdline" % last_pid
if os.path.exists(last_process_cmdline):
with open(last_process_cmdline, "r") as _file:
cmdline = _file.read()
if script_name in cmdline:
raise Exception("Script already running...")
with open(pidfile, "w") as _file:
pid = str(os.getpid())
_file.write(pid)
def main():
"""Your application logic goes here"""
if __name__ == "__main__":
create_pidfile()
main()
这种方法在不依赖任何外部模块的情况下效果很好。