Python多进程使用
【Python之旅】第六篇(六):Python多进程使用
香飘叶子 2016-05-10 10:57:50 浏览190 评论0
摘要: 关于进程与线程的对比,下面的解释非常好的说明了这两者的区别: 这里主要说明关于Python多进程的下面几点: 1 2 3 4 5 6 7 1.多进程的使用方法 2.进程间的通信之multiprocessing.Manager()使用 3.Python进程池 ...
关于进程与线程的对比,下面的解释非常好的说明了这两者的区别:
这里主要说明关于Python多进程的下面几点:
1
2
3
4
5
6
7
|
1 .多进程的使用方法 2 .进程间的通信之multiprocessing.Manager()使用 3 .Python进程池 ( 1 )比较简单的例子 ( 2 )多个进程多次并发的情况 ( 3 )验证apply.async方法是非阻塞的 ( 4 )验证apply.async中的 get ()方法是阻塞的 |
1.多进程的使用方法
直接给出下面程序代码及注释:
1
2
3
4
5
6
7
8
9
10
|
from multiprocessing import Process #从多进程模块中导入Process import time def sayHi(name): print 'Hi my name is %s' % name time.sleep( 3 ) for i in range( 10 ): p = Process(target=sayHi, args=(i,)) #调用多进程使用方法 p.start() #开始执行多进程 |
程序执行结果如下:
1
2
3
4
5
6
7
8
9
10
11
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ python multiprocssing8.py Hi my name is 2 Hi my name is 3 Hi my name is 6 Hi my name is 1 Hi my name is 4 Hi my name is 5 Hi my name is 0 Hi my name is 7 Hi my name is 8 Hi my name is 9 |
输出顺序不一致,则是因为屏幕的抢占问题而已,但不同的进程执行是并发的。在执行程序的过程中,可以打开另一个窗口来查看进程的执行情况(上面sleep了3秒,所以速度一定要快):
1
2
3
4
5
6
7
8
9
10
11
12
13
|
xpleaf@xpleaf-machine:~$ ps -ef | grep mul* xpleaf 10468 1827 1 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10469 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10470 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10471 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10472 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10473 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10474 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10475 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10476 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10477 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10478 10468 0 19 : 34 pts/ 1 00 : 00 : 00 python multiprocssing8.py xpleaf 10480 8436 0 19 : 34 pts/ 2 00 : 00 : 00 grep --color=auto mul* |
可以看到上面有11个进程,但是前面其实只开了10个进程,为什么会有11个呢?那是因为有一个主进程,即这整一个程序本身,而其它的10个进程则是这个主进程下面的子进程,但无论如何,它们都是进程。
同多线程一样,多进程也有join方法,即可以在p.start()后面加上去,一个进程的执行需要等待上一个进程执行完毕后才行,这就相当于进程的执行就是串行的了。
2.进程间的通信multiprocessing.Manager()使用
Manager()返回的manager对象控制了一个server进程,此进程包含的python对象可以被其他的进程通过proxies来访问。从而达到多进程间数据通信且安全。
Manager支持的类型有list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value和Array。
直接看下面的一个例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import multiprocessing import time def worker(d, key, value): d[key] = value mgr = multiprocessing.Manager() d = mgr.dict() jobs = [] #用来接收多进程函数的返回的结果,存放的是函数的入口 for i in range( 10 ): jobs.append(multiprocessing.Process(target=worker,args=(d,i,i*i))) for j in jobs: #执行存放的函数入口 j.start() for j in jobs: #检测进程是否执行完毕 j.join() #time.sleep( 1 ) #如果有join()来进程进程是否执行完毕,则这里可以省略 print ( 'Results:' ) print d |
程序执行结果如下:
1
2
3
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ python multiprocssing_manager9.py Results: { 0 : 0 , 1 : 1 , 2 : 4 , 3 : 9 , 4 : 16 , 5 : 25 , 6 : 36 , 7 : 49 , 8 : 64 , 9 : 81 } |
3.Python进程池
前面我们讲过CPU在某一时刻只能执行一个进程,那为什么上面10个进程还能够并发执行呢?实际在CPU在处理上面10个进程时是在不停的切换执行这10个进程,但由于上面10个进程的程序代码都是十分简单的,并没有涉及什么复杂的功能,并且,CPU的处理速度实在是非常快,所以这样一个过程在我们人为感知里确实是在并发执行的,实际只不过是CPU在不停地切换而已,这是通过增加切换的时间来达到目的的。
10个简单的进程可以产生这样的效果,那试想一下,如果我有100个进程需要CPU执行,但因为CPU还要进行其它工作,只能一次再处理10个进程(切换处理),否则有可能会影响其它进程工作,这下可怎么办?这时候就可以用到Python中的进程池来进行调控了,在Python中,可以定义一个进程池和这个池的大小,假如定义进程池的大小为10,那么100个进程可以分10次放进进程池中,然后CPU就可以10次并发完成这100个进程了。
(1)比较简单的例子
程序代码及注释如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
from multiprocessing import Process,Pool #导入Pool模块 import time def sayHi(num): time.sleep( 1 ) return num*num p = Pool(processes= 5 ) #定义进程池的数量为 5 result = p.apply_async(sayHi, [ 10 ]) #开始执行多进程,async为异步执行,即不会等待其它 #子进程的执行结果,为非阻塞模式,除非使用了 get ()方法, get ()方法会等待子进程返回执行结果, #再去执行下一次进程,可以看后面的例子;同理下有apply方法,阻塞模式,会等待子进程返回执行结果 print result. get () # get ()方法 |
程序执行结果如下:
1
2
3
4
5
6
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ time python multiprocssing_pool10.py 100 real 0m1.066s user 0m0.016s sys 0m0.032s |
虽然是定义了进程池的数量为5,但由于这里只执行一个子进程,所以时间为1秒多。
上面的程序可以改写为下面的形式:
1
2
3
4
5
6
7
8
9
10
11
12
|
from multiprocessing import Process,Pool import time def sayHi(num): time.sleep( 1 ) return num*num p = Pool(processes= 5 ) result = p.map(sayHi,range( 3 )) for i in result:print i |
执行结果如下:
1
2
3
4
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ python multiprocssing_pool10.py 0 1 4 |
(2)多个进程多次并发的情况:解释进程池作用以及多进程并发执行消耗切换时间
修改上面的程序代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
from multiprocessing import Process,Pool import time def sayHi(num): time.sleep( 1 ) return num*num p = Pool(processes= 5 ) result_list = [] for i in range( 30 ): result_list.append(p.apply_async(sayHi, [i])) for res in result_list: print res. get () |
程序执行结果如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ python multiprocssing_pool_2_11.py 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 784 841 |
每一部分数字之间有空白是因为我按了回车键的原因,以让这个结果更加明显,同时也可以知道,上面的30个进程是分6次来完成的,是因为我定义了进程池的数量为5(30/6=5),为了更有说服力,可以看一下程序的执行时间:
1
2
3
4
5
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ time python multiprocssing_pool_2_11.py | grep real real 0m6.143s user 0m0.052s sys 0m0.028s |
可以看到执行的时间为6秒多,之所以不是6秒是因为主程序本身的执行需要一点时间,同时进程间的切换也是需要时间的(这里为5个进程间的切换,因为每次并发执行的进程数为5个),为了说明这一点,我们可以把pool大小改为100,但依然是并发执行6次,程序代码修改为如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
from multiprocessing import Process,Pool import time def sayHi(num): time.sleep( 1 ) return num*num p = Pool(processes= 100 ) result_list = [] for i in range( 600 ): result_list.append(p.apply_async(sayHi, [i])) for res in result_list: print res. get () |
再观察一下执行时间:
1
2
3
4
5
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ time python multiprocssing_pool_2_11.py | grep real real 0m6.371s user 0m0.080s sys 0m0.128s |
虽然相差的时间只是零点几秒,但随着并发执行进程数的增加,进程间切换需要的时间越来越多,程序执行的时间也就越多,特别是当单个进程非常消耗CPU资源时。
(3)验证apply.sync方法是非阻塞的
第一个程序代码的注释中,我们说apply.sync方法是非阻塞的,也就是说,无论子进程是否已经执行完毕,只要主进程执行完毕,程序就会退出,看下面的探索过程,以验证一下。
看下面的程序代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
from multiprocessing import Process,Pool import time def sayHi(num): time.sleep( 10 ) return num*num p = Pool(processes= 5 ) result_list = [] for i in range( 30 ): result_list.append(p.apply_async(sayHi, [i])) for res in result_list: print res. get () |
先查看程序的执行时间:
1
2
3
4
5
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ time python multiprocssing_pool_2_11.py | grep real real 0m0.149s user 0m0.020s sys 0m0.024s |
第一次运行这个程序时,出乎了我的意料,本来我以为这个程序的执行要18s左右才对的,因为子进程并发执行了6次,每一次都sleep了3s(并发执行的进程数比较少,切换的时间就不算上去了),但实际上也并非是如此,因为我查看系统进程时,情况是下面这样的:
1
2
|
xpleaf@xpleaf-machine:~$ ps -ef | grep mul* xpleaf 11499 8436 0 20 : 35 pts/ 2 00 : 00 : 00 grep --color=auto mul* |
如果原来我的想法是正确的,那么应该在这里可以看到多个我执行的进程才对(因为有个3s的时间在子进程里,并发6次,18s,应该有才对),为什么会没有呢?后来我把程序代码修改为如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
from multiprocessing import Process,Pool import time def sayHi(num): time.sleep( 3 ) return num*num p = Pool(processes= 5 ) result_list = [] for i in range( 30 ): result_list.append(p.apply_async(sayHi, [i])) time.sleep( 3 ) |
即我在主程序中添加了time.sleep(3)的代码,还是先查看时间:
1
2
3
4
5
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ time python multiprocssing_pool_2_11.py | grep real real 0m3.107s user 0m0.040s sys 0m0.032s |
在上面程序执行过程中,迅速地在另一个窗口查看系统进程:
1
2
3
4
5
6
7
8
|
xpleaf@xpleaf-machine:~$ ps -ef | grep mul* xpleaf 11515 1827 4 20 : 39 pts/ 1 00 : 00 : 00 python multiprocssing_pool_2_11.py xpleaf 11517 11515 0 20 : 39 pts/ 1 00 : 00 : 00 python multiprocssing_pool_2_11.py xpleaf 11518 11515 0 20 : 39 pts/ 1 00 : 00 : 00 python multiprocssing_pool_2_11.py xpleaf 11519 11515 0 20 : 39 pts/ 1 00 : 00 : 00 python multiprocssing_pool_2_11.py xpleaf 11520 11515 0 20 : 39 pts/ 1 00 : 00 : 00 python multiprocssing_pool_2_11.py xpleaf 11521 11515 0 20 : 39 pts/ 1 00 : 00 : 00 python multiprocssing_pool_2_11.py xpleaf 11526 8436 0 20 : 39 pts/ 2 00 : 00 : 00 grep --color=auto mul* |
程序执行结束后,即显示了上面的时间后,我再查看进程:
1
2
|
xpleaf@xpleaf-machine:~$ ps -ef | grep mul* xpleaf 11529 8436 0 20 : 39 pts/ 2 00 : 00 : 00 grep --color=auto mul* |
于是,上网查找了一些资料,apply.async是非阻塞的,所谓的非阻塞是指:主进程不会等待子进程的返回结果后再结束;正常情况下,如果是产生于主进程的子进程,在主进程结束后也应该不会退出才对,但因为这里的子进程是由pool进程池产生的,所以主进程结束,pool即关闭,因为pool池中的进程需要pool调度才能执行,因此当pool关闭后,这些子进程也随即结束运行。
其实join方法就可以实现一个功能,就是让子进程结束后才结束主进程,把上面的代码修改为如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
from multiprocessing import Process,Pool import time def sayHi(num): time.sleep( 3 ) return num*num p = Pool(processes= 5 ) result_list = [] for i in range( 30 ): result_list.append(p.apply_async(sayHi, [i])) p.close() #执行p.join()前需要先关闭进程池,否则会出错 p.join() #主进程等待子进程执行完后才结束 |
查看执行的时间:
1
2
3
4
5
6
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ time python multiprocssing_pool_2_11.py | grep real real 0m18.160s user 0m0.048s sys 0m0.044s xpleaf@xpleaf-mac |
当然,结果就是我们可以预料的了。
(4)验证apply.async中的get()方法是阻塞的
使用apply.sync中的get()方法时,是会阻塞的,即apply.sync会等进程返回执行结果后才会执行下一个进程,其实(2)中的第一个例子就可以体现出来(程序中有get(),于是就忽略apply.async的非阻塞特性,等待子进程返回结果并使用get()获得结果)。这里不妨看下来一个例子,以实现虽然是多进程并发,但是因为get()的缘故,进程是串行执行的。
程序代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
|
from multiprocessing import Process,Pool import time def sayHi(num): time.sleep( 1 ) return num*num p = Pool(processes= 5 ) for i in range( 20 ): result = p.apply_async(sayHi, [i]) print result. get () |
程序执行结果如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day6$ time python multiprocssing_pool10.py 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 real 0m20.194s user 0m0.044s sys 0m0.064s |
结果是一个一个输出的,其实从程序执行的时间也可以推算出来,至于为什么,那就是因为get()导致阻塞的原因了。
上面说得其实思路是不太清晰,主要是因为对多进程的掌握是还不够多的,在这个探索的过程中,自己也是慢慢接触到了许多编程思想和方法,还有和操作系统相关的知识,往后深入学习后,如果有时间,会再完善一下。
Python多进程使用的更多相关文章
- Python多进程编程
转自:Python多进程编程 阅读目录 1. Process 2. Lock 3. Semaphore 4. Event 5. Queue 6. Pipe 7. Pool 序. multiproces ...
- Python多进程(1)——subprocess与Popen()
Python多进程方面涉及的模块主要包括: subprocess:可以在当前程序中执行其他程序或命令: mmap:提供一种基于内存的进程间通信机制: multiprocessing:提供支持多处理器技 ...
- python多进程断点续传分片下载器
python多进程断点续传分片下载器 标签:python 下载器 多进程 因为爬虫要用到下载器,但是直接用urllib下载很慢,所以找了很久终于找到一个让我欣喜的下载器.他能够断点续传分片下载,极大提 ...
- Python多进程multiprocessing使用示例
mutilprocess简介 像线程一样管理进程,这个是mutilprocess的核心,他与threading很是相像,对多核CPU的利用率会比threading好的多. import multipr ...
- Python多进程并发(multiprocessing)用法实例详解
http://www.jb51.net/article/67116.htm 本文实例讲述了Python多进程并发(multiprocessing)用法.分享给大家供大家参考.具体分析如下: 由于Pyt ...
- python 多进程开发与多线程开发
转自: http://tchuairen.blog.51cto.com/3848118/1720965 博文作者参考的博文: 博文1 博文2 我们先来了解什么是进程? 程序并不能单独运行,只有将程 ...
- Python多进程----从入门到放弃
Python多进程 (所有只写如何起多进程跑数据,多进程数据汇总处理不提的都是耍流氓,恩,就这么任性) (1)进程间数据问题,因为多进程是完全copy出的子进程,具有独立的单元,数据存储就是问题了 ( ...
- day-4 python多进程编程知识点汇总
1. python多进程简介 由于Python设计的限制(我说的是咱们常用的CPython).最多只能用满1个CPU核心.Python提供了非常好用的多进程包multiprocessing,他提供了一 ...
- python 多进程 logging:ConcurrentLogHandler
python 多进程 logging:ConcurrentLogHandler python的logging模块RotatingFileHandler仅仅是线程安全的,如果多进程多线程使用,推荐 Co ...
随机推荐
- unix 环境高级编程 读书笔记与习题解答第四篇
第一章 第六节 第一小节 这一章没有程序设计和API方面的深入学习,而是注重介绍了unix操作系统中的原始数据类型和系统原型函数,错误处理方面的知识. ____unistd.h____ 该文件包含了u ...
- WCF返回JSON的详细配置
开发环境:VS2008,c# 1.新建个WCF服务网站 文件-新建-网站-WCF服务 2,运行一下,提示配置WEB.CONFIG,点击确认. 3,打开web.config增加如下节点: <ser ...
- 开源中国iOS客户端学习
开源中国iOS客户端学习 续写前言 <开源中国iOS客户端学习>续写前系列博客 http://blog.csdn.net/column/details/xfzl-kykhd.html ...
- BZOJ 3240 矩阵游戏
Description 婷婷是个喜欢矩阵的小朋友,有一天她想用电脑生成一个巨大的\(n\)行\(m\)列的矩阵(你不用担心她如何存储).她生成的这个矩阵满足一个神奇的性质:若用\(F[i][j]\)来 ...
- BZOJ 1069 最大土地面积
Description 在某块平面土地上有N个点,你可以选择其中的任意四个点,将这片土地围起来,当然,你希望这四个点围成的多边形面积最大. Input 第1行一个正整数N,接下来N行,每行2个数x,y ...
- 关于javascript
Client-Language-----------------------JavaScript/Object-C/Java/C# HTML5 DOM/Template/Data/Ajax/Regul ...
- SharePoint2013 Powershell script to get site Title, Site Owner, Site user count and usage
Powershell script to get site Title, Site Owner, Site user count and usage Add-PSSnapin microsoft.sh ...
- 我的HttpClients工具
import java.io.IOException; import javax.ws.rs.core.MediaType; import org.apache.commons.httpclient. ...
- Android Wear开发 - 卡片通知 - 第一节 : 添加Android Wear通知特性
一. 前言说明 Android Wear大部分显示形式是卡片的形式,而最简单地支持Android Wear方式就是用通知**Notification**.而实现最简单的,非高度自定义的通知,则只需要在 ...
- latch介绍
latch是一种锁,用来实现对Oracle所有共享数据结构的串行化访问.共享池就是这样一个例子, 这是系统全局区中一个庞大的共享数据结构,Oracle正是在这里存储已解析,已编译的SQL. 修改这个共 ...