python怎么实现一个进程

2025-02-12 23:53:35

推荐回答（1个）

回答1：

想要充分利用多核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())1234567891011121314151617181920

执行结果：

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())123456789101112131415161718192021

执行结果：

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())12345678910111213141516171819202122232425262728

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

创建多个进程

很多时候系统都需要创建多个进程以提高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) #主进程执行时间123456789101112131415161718192021222324

执行结果：
开头部分

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.

最新问答

我有一个电竞梦想作文370字

女孩如何打扮自己？才能使自己变得漂亮起来！

南昌到都昌坐车多久

什么快递到重庆市奉节县康乐镇郭家村

芳疗师怎么考，需要什么，成为芳疗师的所有事项都是什么？

学校艺术节想跳个群体的韩国舞蹈比较简单的那种

百家姓什么姓排最前面

华人明星与日韩的女明星..一般个子比较矮的是?

李世民唯一一场败仗是输给谁了？

我和一个对我很好很好的男人分手了，因为我对他没感觉，可是我又舍不得。我18岁我以后还会找到对我很