python起进程的函数 python进程join

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

在Python中，我们通过标准库中的subprocess包来fork一个子进程，并运行一个外部的程序。

使用subprocess包中的函数创建子进程的时候，要注意:

1) 在创建子进程之后，父进程是否暂停，并等待子进程运行。

2) 函数返回什么

3) 当returncode不为0时，父进程如何处理。

subprocess.call()

父进程等待子进程完成

返回退出信息

subprocess.check_call()

父进程等待子进程完成

返回0

检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性，可用try...except...来检查。

subprocess.check_output()

父进程等待子进程完成

返回子进程向标准输出的输出结果

检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性和output属性，output属性为标准输出的输出结果，可用try...except...来检查。

这三个函数的使用方法相类似，我们以subprocess.call()来说明:

import subprocess

rc = subprocess.call(["ls","-l"])

实际上，我们上面的三个函数都是基于Popen()的封装(wrapper)。这些封装的目的在于让我们容易使用子进程。当我们想要更个性化我们的需求的时候，就要转向Popen类，该类生成的对象用来代表子进程。

与上面的封装不同，Popen对象创建后，主程序不会自动等待子进程完成。我们必须调用对象的wait()方法，父进程才会等待 (也就是阻塞block)：

import subprocess

child = subprocess.Popen(["ping","-c","5",""])

child.wait()

print("parent process")

此外，你还可以在父进程中对子进程进行其它操作，比如我们上面例子中的child对象:

child.poll() # 检查子进程状态

child.kill() # 终止子进程

child.send_signal() # 向子进程发送信号

child.terminate() # 终止子进程

因此，如果不希望当前进程被阻塞，你可以使用Popen对象进行操作。

相关问答

Q1: python 多进程

基于官方文档：

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

我就是喜欢抄官方的，哈哈

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

这种方法和 Thread 是一样的。

上图中，我写python起进程的函数了 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 虚拟，在内存python起进程的函数？python起进程的函数？

使用 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

Q2: 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进程join的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。