python父进程退出

⑴ python Multiprocessing问题

给个示例：

#-*-coding:utf-8-*-
importthread,threading
importtime

defFuncTest(tdata):
printtdata

classmythread(threading.Thread):
def__init__(self,threadname):
threading.Thread.__init__(self)

defrun(self):
lock.acquire()
FuncTest(ft)
lock.release()

defMutiThread(num):
threads=[]
i=0
globalft
forxinxrange(num):
threads.append(mythread(num))
fortinthreads:
time.sleep(0.5)
lock.acquire()
ft=GetThreadParam(datafile,num,i)
#print'[%s]Thread:%s,Testdata:%s'%(time.ctime(),t,ft)
i=i+1
t.start()
lock.release()
fortinthreads:
t.join()

defGetThreadParam(datafile,num,curthread):
#线程数需要小于文件行数
f=open(datafile,'r')
lines=f.readlines()
divres=divmod(len(lines),num)
ifcurthread<(num-1):
res=lines[curthread*divres[0]:(curthread+1)*divres[0]]
elifcurthread==(num-1):
res=lines[curthread*divres[0]:((curthread+1)*divres[0]+divres[1])]
returnres
f.close()

if__name__=='__main__':

globalnum,lock
datafile='a.txt'

num=3#num并发数

lock=threading.Lock()
MutiThread(num)

a.txt文件内容如下

1

2

3

4

5

6

7

8

9

10

3个线程并发时，运行结果：

>>>

['1 ', '2 ', '3 ']

['4 ', '5 ', '6 ']

['7 ', '8 ', '9 ', '10']

⑵ python多进程如何在主进程结束后 子进程也跟着退出

办法很多。通常的办法是，子线程出异常后，主进程检查到它的状态不正常，然后自己主动将其余线程退出，最后自己再退出。这是稳妥的办法。

另外的办法是，某一个子线程专用于监控状态。它发现状态不对时，直接强制进程退出。办法1，发消息给主进程，让主进程退出。办法2：用kill, pskill等方法，直接按进程PID杀进程。

⑶ python怎么实现一个进程

想要充分利用多核CPU资源，Python中大部分情况下都需要使用多进程，Python中提供了multiprocessing这个包实现多进程。multiprocessing支持子进程、进程间的同步与通信，提供了Process、Queue、Pipe、Lock等组件。

开辟子进程

multiprocessing中提供了Process类来生成进程实例

Process([group [, target [, name [, args [, kwargs]]]]])1

• group分组，实际上不使用

• target表示调用对象，你可以传入方法的名字

• args表示给调用对象以元组的形式提供参数，比如target是函数a，他有两个参数m，n，那么该参数为args=(m, n)即可

• kwargs表示调用对象的字典

• name是别名，相当于给这个进程取一个名字

先来个小例子：

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime()) #获取当前进程号和正在运行是的时间


• time.sleep(wTime) #等待（休眠）


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,)) #申请子进程


• p.start() #运行进程


• print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())12345678910111213141516171819



运行结果：

Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017

根据运行结果可知，父进程运行结束后子进程仍然还在运行，这可能造成僵尸（ zombie）进程。

通常情况下，当子进程终结时，它会通知父进程，清空自己所占据的内存，并在内核里留下自己的退出信息。父进程在得知子进程终结时，会从内核中取出子进程的退出信息。但是，如果父进程早于子进程终结，这可能造成子进程的退出信息滞留在内核中，子进程成为僵尸（zombie）进程。当大量僵尸进程积累时，内存空间会被挤占。

有什么办法可以避免僵尸进程呢？
这里介绍进程的一个属性 deamon，当其值为TRUE时，其父进程结束，该进程也直接终止运行（即使还没运行完）。
所以给上面的程序加上p.deamon = true，看看效果。

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(wTime)


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,))


• p.daemon = True #加入daemon


• p.start() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())



执行结果：

Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017

这是问题又来了，子进程并没有执行完，这不是所期望的结果。有没办法将子进程执行完后才让父进程结束呢？
这里引入p.join()方法，它使子进程执行结束后，父进程才执行之后的代码

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(wTime)


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,))


• p.daemon = True


• p.start()


• p.join() #加入join方法


• print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())21



执行结果：

subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017

这样所有的进程就能顺利的执行了。

将进程定义成类

通过继承Process类，来自定义进程类，实现run方法。实例p通过调用p.start()时自动调用run方法。
如下：

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timeclass Myprocess(Process):



• def __init__(self, wTime):


• Process.__init__(self)


• self.wTime = wTime def run(self):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(self.wTime)


• n += 1if __name__ == "__main__":


• p = Myprocess(2)


• p.daemon = True


• p.start() #自动调用run方法


• p.join() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())2122232425262728



执行结果和上一个例子相同。

创建多个进程

很多时候系统都需要创建多个进程以提高CPU的利用率，当数量较少时，可以手动生成一个个Process实例。当进程数量很多时，或许可以利用循环，但是这需要程序员手动管理系统中并发进程的数量，有时会很麻烦。这时进程池Pool就可以发挥其功效了。可以通过传递参数限制并发进程的数量，默认值为CPU的核数。
直接上例子：

• # -*- coding:utf-8 -*-from multiprocessing import Process,Poolimport os,timedef run_proc(name): ##定义一个函数用于进程调用


• for i in range(5):


• time.sleep(0.2) #休眠0.2秒


• print 'Run child process %s (%s)' % (name, os.getpid())#执行一次该函数共需1秒的时间if __name__ =='__main__': #执行主进程


• print 'Run the main process (%s).' % (os.getpid())


• mainStart = time.time() #记录主进程开始的时间


• p = Pool(8) #开辟进程池


• for i in range(16): #开辟14个进程


• p.apply_async(run_proc,args=('Process'+str(i),))#每个进程都调用run_proc函数，


• #args表示给该函数传递的参数。



• print 'Waiting for all subprocesses done ...'


• p.close() #关闭进程池


• p.join() #等待开辟的所有进程执行完后，主进程才继续往下执行


• print 'All subprocesses done'


• mainEnd = time.time() #记录主进程结束时间


• print 'All process ran %0.2f seconds.' % (mainEnd-mainStart) #主进程执行时间21222324



执行结果：
开头部分

Run the main process (30920).
Waiting for all subprocesses done …
Run child process Process0 (32396)
Run child process Process3 (25392)
Run child process Process1 (28732)
Run child process Process2 (32436)

末尾部分：

Run child process Process15 (25880)
All subprocesses done
All process last 2.49 seconds.

相关说明：

这里进程池对并发进程的限制数量为8个，而程序运行时会产生16个进程，进程池将自动管理系统内进程的并发数量，其余进程将会在队列中等待。限制并发数量是因为，系统中并发的进程不是越多越好，并发进程太多，可能使CPU大部分的时间用于进程调度，而不是执行有效的计算。

采用多进程并发技术时，就单个处理机而言，其对进程的执行是串行的。但具体某个时刻哪个进程获得CPU资源而执行是不可预知的（如执行结果的开头部分，各进程的执行顺序不定），这就体现了进程的异步性。

如果单个程序执行14次run_proc函数，那么它会需要至少16秒,通过进程的并发，这里只需要2.49秒，可见并发的优势。

⑷ 如何使用Python，在Windows下保证父进程退出时，子进程同样退出

有两种办法，
1.一种办法是在父进程fork出子进程的时候把子进程pid写入一个文件中，这种父进程捕捉到sigkill或者sighup信号的时候读取文件kill 子进程们的pid。
2.还有一种方法就是子进程定时调用os.getppid()来判断是否自己已经成为了僵尸进程，如果是赶紧把事情做完正常结束掉。
第一种方法暴力有效，第二种方法更加安全。
按
照unix设计哲学，进程是程序执行的最小单元，而他们是天生平等的，没有父进程权利就大一些就能剥夺子进程的生命周期，父进程没了，init进程就要喜
当爹。所以你的问题的重点不在于父进程结束子进程，再于一个进程如何结束另一个进程，从这个角度(ipc)上去探索，方法还是很多的，发挥想象力吧。

⑸ python中怎么判断子进程和父进程

python执行ps -ef | grep XXX XXX为你的进程，当有返回值的时候，说明你的进程存在，python检查系统进程其实调用的也是linux的shell

⑹ python输入exit（）后为什么直接退出了

打开的不是同一个程序，
第一张图是cmd命令提示符。
第二张图是IDLE。
自然效果不一样

⑺ python可以多进程吗

想要充分利用多核CPU资源，Python中大部分情况下都需要使用多进程，Python中提供了multiprocessing这个包实现多进程。multiprocessing支持子进程、进程间的同步与通信，提供了Process、Queue、Pipe、Lock等组件。

开辟子进程
multiprocessing中提供了Process类来生成进程实例

Process([group [, target [, name [, args [, kwargs]]]]])
group分组，实际上不使用
target表示调用对象，你可以传入方法的名字
args表示给调用对象以元组的形式提供参数，比如target是函数a，他有两个参数m，n，那么该参数为args=(m, n)即可
kwargs表示调用对象的字典
name是别名，相当于给这个进程取一个名字
先来个小例子：

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime()) #获取当前进程号和正在运行是的时间
time.sleep(wTime) #等待（休眠）
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,)) #申请子进程
p.start() #运行进程
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
运行结果：

Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017

根据运行结果可知，父进程运行结束后子进程仍然还在运行，这可能造成僵尸（ zombie）进程。

通常情况下，当子进程终结时，它会通知父进程，清空自己所占据的内存，并在内核里留下自己的退出信息。父进程在得知子进程终结时，会从内核中取出子进程的退出信息。但是，如果父进程早于子进程终结，这可能造成子进程的退出信息滞留在内核中，子进程成为僵尸（zombie）进程。当大量僵尸进程积累时，内存空间会被挤占。

有什么办法可以避免僵尸进程呢？
这里介绍进程的一个属性 deamon，当其值为TRUE时，其父进程结束，该进程也直接终止运行（即使还没运行完）。
所以给上面的程序加上p.deamon = true，看看效果。

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
time.sleep(wTime)
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,))
p.daemon = True #加入daemon
p.start()
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
执行结果：

Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017

这是问题又来了，子进程并没有执行完，这不是所期望的结果。有没办法将子进程执行完后才让父进程结束呢？
这里引入p.join()方法，它使子进程执行结束后，父进程才执行之后的代码

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
time.sleep(wTime)
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,))
p.daemon = True
p.start()
p.join() #加入join方法
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
执行结果：

subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017

这样所有的进程就能顺利的执行了。

⑻ 如何在python脚本中新建一个守护子进程

函数实现
[html] view plain
#!/usr/bin/env python
#coding: utf-8
import sys, os

'''将当前进程fork为一个守护进程
注意：如果你的守护进程是由inetd启动的，不要这样做！inetd完成了
所有需要做的事情，包括重定向标准文件描述符，需要做的事情只有chdir()和umask()了
'''

def daemonize (stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
#重定向标准文件描述符（默认情况下定向到/dev/null）
try:
pid = os.fork()
#父进程(会话组头领进程)退出，这意味着一个非会话组头领进程永远不能重新获得控制终端。
if pid > 0:
sys.exit(0) #父进程退出
except OSError, e:
sys.stderr.write ("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror) )
sys.exit(1)

#从母体环境脱离
os.chdir("/") #chdir确认进程不保持任何目录于使用状态，否则不能umount一个文件系统。也可以改变到对于守护程序运行重要的文件所在目录
os.umask(0) #调用umask(0)以便拥有对于写的任何东西的完全控制，因为有时不知道继承了什么样的umask。
os.setsid() #setsid调用成功后，进程成为新的会话组长和新的进程组长，并与原来的登录会话和进程组脱离。

#执行第二次fork
try:
pid = os.fork()
if pid > 0:
sys.exit(0) #第二个父进程退出
except OSError, e:
sys.stderr.write ("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror) )
sys.exit(1)

#进程已经是守护进程了，重定向标准文件描述符

for f in sys.stdout, sys.stderr: f.flush()
si = open(stdin, 'r')
so = open(stdout, 'a+')
se = open(stderr, 'a+', 0)
os.p2(si.fileno(), sys.stdin.fileno()) #p2函数原子化关闭和复制文件描述符
os.p2(so.fileno(), sys.stdout.fileno())
os.p2(se.fileno(), sys.stderr.fileno())

#示例函数：每秒打印一个数字和时间戳
def main():
import time
sys.stdout.write('Daemon started with pid %d\n' % os.getpid())
sys.stdout.write('Daemon stdout output\n')
sys.stderr.write('Daemon stderr output\n')
c = 0
while True:
sys.stdout.write('%d: %s\n' %(c, time.ctime()))
sys.stdout.flush()
c = c+1
time.sleep(1)

if __name__ == "__main__":
daemonize('/dev/null','/tmp/daemon_stdout.log','/tmp/daemon_error.log')
main()
可以通过命令ps -ef | grep daemon.py查看后台运行的继承，在/tmp/daemon_error.log会记录错误运行日志，在/tmp/daemon_stdout.log会记录标准输出日志。