python起进程的函数 python启动进程并获取pid

python 多进程

基于官方文档：

日乐购python起进程的函数，刚才看到python起进程的函数的一个博客，写的都不太对，还是基于官方的比较稳妥

python起进程的函数我就是喜欢抄官方的，哈哈

通常我们使用Process实例化一个进程，并调用 他的 start() 方法启动它。

这种方法和 Thread 是一样的。

上图中，我写了 p.join() 所以主进程是 等待 子进程执行完后，才执行 print("运行结束")

否则就是反过来了（这个不一定，看你的语句了，顺序其实是随机的）例如：

主进加个 sleep

所以不加join() ,其实子进程和主进程是各干各的，谁也不等谁。都执行完后，文件运行就结束了

上面我们用了 os.getpid() 和 os.getppid() 获取 当前进程，和父进程的id

下面就讲一下，这两个函数的用法：

os.getpid()

返回当前进程的id

os.getppid()

返回父进程的id。 父进程退出后，unix 返回初始化进程（1）中的一个

windows返回相同的id (可能被其他进程使用了)

这也就解释了，为啥我上面 的程序运行多次， 第一次打印的parentid 都是 14212 了。

而子进程的父级 process id 是调用他的那个进程的 id ： 1940

视频笔记：

多进程：使用大致方法：

参考： 进程通信（pipe和queue）

pool.map （函数可以有return 也可以共享内存或queue） 结果直接是个列表

poll.apply_async() （同map,只不过是一个进程，返回结果用 xx.get() 获得）

报错：

参考 ：

把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。

结果：

这个肯定有解释的

测试多进程计算效果：

进程池运行：

结果：

普通计算：

我们同样传入 1 2 10 三个参数测试：

其实对比下来开始快了一半的；

我们把循环里的数字去掉一个 0；

单进程：

多进程：

两次测试 单进程/进程池 分别为 0.669 和 0.772 几乎成正比的。

问题 二：

视图：

post 视图里面

Music 类：

直接报错：

写在 类里面也 在函数里用 self.pool 调用也不行，也是相同的错误。

最后 把 pool = Pool 直接写在 search 函数里面，奇迹出现了：

前台也能显示搜索的音乐结果了

总结一点，进程这个东西，最好 写在 直接运行的函数里面，而不是 一个函数跳来跳去。因为最后可能 是在子进程的子进程运行的，这是不许的，会报错。

还有一点，多进程运行的函数对象，不能是 lambda 函数。也许lambda 虚拟，在内存？？

使用 pool.map 子进程 函数报错，导致整个 pool 挂了:

参考：

主要你要，对函数内部捕获错误，而不能让异常抛出就可以了。

关于map 传多个函数参数

我一开始，就是正常思维，多个参数，搞个元祖，让参数一一对应不就行了：

报错：

参考：

普通的 process 当让可以穿多个参数，map 却不知道咋传的。

apply_async 和map 一样，不知道咋传的。

最简单的方法：

使用 starmap 而不是 map

结果：

子进程结束

1.8399453163146973

成功拿到结果了

关于map 和 starmap 不同的地方看源码：

关于apply_async() ,我没找到多参数的方法，大不了用 一个迭代的 starmap 实现。哈哈

关于 上面源码里面有 itertools.starmap

itertools 用法参考：

有个问题，多进程最好不要使用全部的 cpu , 因为这样可能影响其他任务，所以 在进程池 添加 process 参数 指定，cpu 个数：

上面就是预留了 一个cpu 干其他事的

后面直接使用 Queue 遇到这个问题：

解决：

Manager().Queue() 代替 Queue()

因为 queue.get() 是堵塞型的，所以可以提前判断是不是 空的，以免堵塞进程。比如下面这样：

使用 queue.empty() 空为True

相关问答

Q1: python进程和线程中的join方法

python中创建进程的方式

一、Process（target=函数名，args=（），name,kwargs）

target:加进程调用的函数名，一般不加括号

name：进程的名字

kwargs：字典参数

args：元组参数，如果参数就一个，记得加逗号’，’

Python多线程与多进程中join()方法的效果是相同的

join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程再终止

import threading

import time

Q2: python 怎么启动一个外部命令程序，并且不阻塞当前进程

1、说明：

python中使用os模块的os.startfile函数就可以实现启动外部命令，并且不阻塞当前的进程。

2、示例：

import os

os.startfile('notepad.exe')

print('我继续执行了，并没有阻塞')

3、执行结果

4、函数说明：

startfile(...)

    startfile(filepath [, operation])

    打开与它的相关联的应用程序的文件。

    startfile只要相关联的应用程序启动返回。

    没有选择等待应用程序关闭了，没办法检索应用程序的退出状态。

    该文件路径是相对于当前目录。如果你想使用绝对路径，确保第一个字符不是斜线（“/”）; 如果是基础Win32 ShellExecute函数不起作用。

Q3: 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())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.

相关说明：

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

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

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

关于python起进程的函数和python启动进程并获取pid的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。