import multiprocessing
import schedule
def worker():
#do some stuff
def sched(argv):
schedule.every(0.01).minutes.do(worker)
while True:
schedule.run_pending()
processs = []
..
..
p = multiprocessing.Process(target=sched,args)
..
..
processs.append(p)
for p in processs:
p.terminate()
优雅地杀死进程列表?
如果不是最简单的方法是什么?
目标是将配置文件重新加载到内存中,所以我想杀死所有子进程并创建其他进程,后者将读取新的配置文件。
修改:添加了更多代码来解释我正在运行while True
循环
修改:这是@dano suggestion之后的新代码
def get_config(self):
from ConfigParser import SafeConfigParser
..
return argv
def sched(self, args, event):
#schedule instruction:
schedule.every(0.01).minutes.do(self.worker,args)
while not event.is_set():
schedule.run_pending()
def dispatch_processs(self, conf):
processs = []
event = multiprocessing.Event()
for conf in self.get_config():
process = multiprocessing.Process(target=self.sched,args=( i for i in conf), kwargs={'event' : event})
processs.append((process, event)
return processs
def start_process(self, process):
process.start()
def gracefull_process(self, process):
process.join()
def main(self):
while True:
processs = self.dispatch_processs(self.get_config())
print ("%s processes running " % len(processs) )
for process, event in processs:
self.start_process(process)
time.sleep(1)
event.set()
self.gracefull_process(process)
关于代码的好处是,我可以编辑配置文件,并且该过程也将重新加载其配置。
问题是只有第一个进程运行而其他进程被忽略。
修改:这节省了我的生命,使用时间表()中的True不是一个好主意,所以我设置refresh_time
而不是
def sched(self, args, event):
schedule.every(0.01).minutes.do(self.worker,args)
for i in range(refresh_time):
schedule.run_pending()
time.sleep(1)
def start_processs(self, processs):
for p,event in processs:
if not p.is_alive():
p.start()
time.sleep(1)
event.set()
self.gracefull_processs(processs)
def gracefull_processs(self, processs):
for p,event in processs:
p.join()
processs = self.dispatch_processs(self.get_config())
self.start_processs(processs)
def main(self):
while True:
processs = self.dispatch_processs(self.get_config())
self.start_processs(processs)
break
print ("Reloading function main")
self.main()
答案 0 :(得分:2)
如果您不介意在worker
完成所有工作后才进行中止,则可以非常简单地添加multiprocessing.Event
来优雅地处理退出:
import multiprocessing
import schedule
def worker():
#do some stuff
def sched(argv, event=None):
schedule.every(0.01).minutes.do(worker)
while not event.is_set(): # Run until we're told to shut down.
schedule.run_pending()
processes = []
..
..
event = multiprocessing.Event()
p = multiprocessing.Process(target=sched,args, kwargs={'event' : event})
..
..
processes.append((p, event))
# Tell all processes to shut down
for _, event in processes:
event.set()
# Now actually wait for them to shut down
for p, _ in processes:
p.join()
答案 1 :(得分:1)
如果你需要安排任何过程的优雅结束,如你的帖子所述,那么应该有一些"软信令" layer,允许在两端发送/接收智能信号,而不依赖于O / S解释(O / S对您的应用程序级上下文和相应工作单元的状态一无所知,目前正在已加工)。
您可能希望在从>>>引用的链接中阅读有关此类软信令方法的内容。 https://stackoverflow.com/a/25373416/3666197
答案 2 :(得分:0)
不,它不会根据你自己的优雅定义来杀死一个进程 - 除非你采取一些额外的步骤。
假设您正在使用unix系统(因为您提到了scp
),terminate
会向子进程发送SIGTERM
信号。您可以在子进程中捕获此信号,并相应地执行操作(等待scp
完成):
import signal
def on_terminate(signum, stack):
wait_for_current_scp_operation()
signal.signal(signal.SIGTERM, on_terminate)