1. 体验多进程的运行速度

#!/usr/bin/env python
# _*_ coding:UTF-8 _*_

from multiprocessing import Pool
import time

def foo(n):
    time.sleep(1)
    return n * n

if __name__ == "__main__":
    pool = Pool(10)
    data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    # 这里只需要等待1S就能得到结果, 因为使用了多进程
    print pool.map(foo, data_list)
    # 这里需要等待10S 才能得到结果, 因为没有使用多进程
    print map(foo, data_list)

结果:

/Users/liudaoqiang/PycharmProjects/numpy/venv/bin/python /Users/liudaoqiang/Project/python_project/day24/processing_test.py
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Process finished with exit code 0

注意:

(1)多进程的优势在于充分利用多核优势,因为多线程都是利用单核,只有多进程才能利用多核

2.子进程与父进程的关系

#!/usr/bin/env python
# _*_ coding:UTF-8 _*_

from multiprocessing import Process
import os

def info(title):
    print "+++++++++++++" + title + "++++++++++++++"
    if hasattr(os, 'getppid'):
        print "ppid: %d" % os.getppid()
    print "pid: %d" % os.getpid()

if __name__ == "__main__":
    info("main process")

    process = Process(target=info, args=("other process", ))
    process.start()
    process.join()

结果:

/Users/liudaoqiang/PycharmProjects/numpy/venv/bin/python /Users/liudaoqiang/Project/python_project/day24/processing_test_2.py
+++++++++++++main process++++++++++++++
ppid: 490
pid: 593
+++++++++++++other process++++++++++++++
ppid: 593
pid: 594

Process finished with exit code 0

3.进程与线程的区别

#!/usr/bin/env python
# _*_ coding:UTF-8 _*_

from multiprocessing import Process
from threading import Thread

def foo(li, item):
    li.append(item)
    print li

if __name__ == "__main__":
    li = []

    #注意:进程是不共享内存的,每个进程都有独立的内存空间;可以利用多核优势;是真正意义上的并发
    print "+++++++++process+++++++++"
    for item in range(5):
        process = Process(target=foo, args=(li, item))
        process.start()
        process.join()

    #注意:线程是共享同一份内存的,每个线程都在抢占内存空间;一个时间片只有一个线程占用内存;不是真正的并发
    print "+++++++++thread++++++++++"
    for item in range(5):
        thread = Thread(target=foo, args=(li, item))
        thread.start()
        thread.join()

结果:

+++++++++process+++++++++
[0]
[1]
[2]
[3]
[4]
+++++++++thread++++++++++
[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]

4. 实现进程间的内存共享(使用进程的队列)

#!/usr/bin/env python
# _*_ coding:UTF-8 _*_

from multiprocessing import Process, Queue

def foo(que, item):
    que.put(item)

if __name__ == "__main__":
    que = Queue()
    for item in range(5):
        process = Process(target=foo, args=(que, item))
        process.start()
    while True:
        print que.get()

结果:

1
2
0
3
4

5. 实现进程间的内存共享(使用Value和Array)

#!/usr/bin/env python
# _*_ coding:UTF-8 _*_

from multiprocessing import Process, Value, Array

def foo(n, a):
    n.value = 3.1415926
    for i in range(len(a)):
        a[i] = -a[i]

if __name__ == "__main__":

    # 这里采用多进程提供的Value对象和Array对象
    num = Value('d', 0)
    arr = Array('i', range(10))

    # 调用foo方法,修改子进程的内存数据
    process = Process(target=foo, args=(num, arr))
    process.start()
    process.join()

    # 打印主进程定义的使用Value和Array定义的数据,发现也被修改;从而断定子进程与主进程共享了内存空间
    print num.value
    print arr[:]

结果:

/Users/liudaoqiang/PycharmProjects/numpy/venv/bin/python /Users/liudaoqiang/Project/python_project/day24/processing_test_5.py
3.1415926
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

Process finished with exit code 0

6. 使用进程池开启进程

#!/usr/bin/env python
#! _*_ coding:UTF-8 _*_

from multiprocessing import Pool
import time

def foo(x):
    print x * x
    time.sleep(1)
    return x * x

if __name__ == "__main__":

    # 这里定义进程池,每次最多只有4个进程并行运行
    pool = Pool(processes=4)

    res_list = []
    for i in range(10):
        # 开启新的进程并启动,相当于Process(target=foo, args=(i))
        res = pool.apply_async(foo, (i, ))
        # 要将进程的运行结果放入列表中,这时其实进程还还有执行函数foo
        res_list.append(res)

    for item in res_list:
        # 只有在区结果的时候,进程才真正执行函数
        print item.get()

结果:看见每个时间段只有4个进程运行

/Users/liudaoqiang/PycharmProjects/numpy/venv/bin/python /Users/liudaoqiang/Project/python_project/day24/processing_test_6.py
0
1
4
9
16
25
36
0
1
49
4
9
64
81
16
25
36
49
64
81

Process finished with exit code 0

老男孩python学习自修第二十四天【多进程】的更多相关文章

  1. 老男孩python学习自修第十四天【序列化和json】

    序列化是使用二进制的方式加密列表,字典或集合,反序列化是解密的过程:序列化开启了两个独立进程进行数据交互的通路 使用pickle进行序列化和反序列化 例如: pickle_test.py #!/usr ...

  2. 老男孩python学习自修第十六天【常用模块之sys和os】

    例子: sys.argv 命令行参数List,第一个元素是程序本身路径 sys.exit(n) 退出程序,正常退出时exit(0) sys.version 获取Python解释程序的版本信息 sys. ...

  3. 老男孩python学习自修第二十三天【多线程】

    1. 线程的创建与运行 #!/usr/bin/env python # _*_ coding:UTF-8 _*_ from threading import Thread def foo(param1 ...

  4. 老男孩 python学习自修第二十二天【文件上传与下载】

    1.使用socket实现文件上传 server.py #!/usr/bin/env python # _*_ coding:UTF-8 _*_ import os import SocketServe ...

  5. 老男孩python学习自修第十九天【异常处理】

    1.常见的错误 TypeError 类型错误 NameError 没有该变量 ValueError 不期望的值 AttributeError 没有该属性 UnboundLocalError 没有该局部 ...

  6. 老男孩python学习自修第十五天【常用模块之time】

    例如: #!/usr/bin/env python # _*_ coding:UTF-8 _*_ import time if __name__ == "__main__": pr ...

  7. 老男孩python学习自修第十天【三元表达式与lambda表达式】

    例如: 1.使用三元表达式给变量赋值 result = '空' if x == None else x 2.使用lambda定义函数 add = lambda x, y: x+y

  8. Python学习笔记(十四)

    Python学习笔记(十四): Json and Pickle模块 shelve模块 1. Json and Pickle模块 之前我们学习过用eval内置方法可以将一个字符串转成python对象,不 ...

  9. Python学习笔记(十四):模块高级

    以Mark Lutz著的<Python学习手册>为教程,每天花1个小时左右时间学习,争取两周完成. --- 写在前面的话 2013-7-23 21:30 学习笔记 1,包导入是把计算机上的 ...

随机推荐

  1. redis单例模式写法

    <?php /**只看红色重点 * =========================================================== * ZW_Memory_Cache * ...

  2. 20175330 实验二《Java面向对象程序设计》实验报告

    一.前期准备:unit的安装与使用:打开idea,Preferences中点击Plugins,在market中搜索junit,如图点选JUnitGenerator V2.0进行安装,安装后会显示ins ...

  3. Pyhon流程控制

    1.条件控制 Python 中用 elif 代替了 else if,所以if语句的关键字为:if – elif – else. 注意: 1.每个条件后面要使用冒号 :,表示接下来是满足条件后要执行的语 ...

  4. 微软Ignite2018——微软宣布新的学习平台:Microsoft Learn

    Ignite 2018 首日感受 头一次参加美国的微软 Ignite 大会,确实规模比国内的大不少.23日是 MVP & RD 的 Pre Day(MVP即Most Valuable Prof ...

  5. linux screen 工具

    一.背景 系统管理员经常需要SSH 或者telent 远程登录到Linux 服务器,经常运行一些需要很长时间才能完成的任务,比如系统备份.ftp 传输等等.通常情况下我们都是为每一个这样的任务开一个远 ...

  6. python之socket模块详解--小白博客

    主要是创建一个服务端,在创建服务端的时候,主要步骤如下:创建socket对象socket——>绑定IP地址和端口bind——>监听listen——>得到请求accept——>接 ...

  7. RabbitMQ总结

    消息队列 三个业务场景:解耦.异步.削峰 带来问题 系统可用性降低:外部依赖越多,越容易挂掉. 系统复杂性提高:重复消费,消息丢失,消息传递的顺序性 一致性问题: 一.如何保证消息的可靠性传输(如何处 ...

  8. 数学基础IV 欧拉函数 Miller Rabin Pollard's rho 欧拉定理 行列式

    找了一些曾经没提到的算法.这应该是数学基础系最后一篇. 曾经的文章: 数学基础I 莫比乌斯反演I 莫比乌斯反演II 数学基础II 生成函数 数学基础III 博弈论 容斥原理(hidden) 线性基(h ...

  9. 如何利用mui实现底部选择器(含日期选择器)?

    1.第一步: 项目中应该引入相应的css和js文件,相关文件可到mui官网查询. <link rel="stylesheet" type="text/css&quo ...

  10. 个人博客作业-week5-敏捷开发方法读后感

    满篇英文对一个非单词狂魔来说真的是很吃力啊… 敏捷软件开发方法是一种从1990年代开始逐渐引起广发关注的一些新型软件开发方法,是一种应对快速变化的需求的一种软件开发能力,他们的具体名称.理念.过程.术 ...