【Python 多进程】 -- 2019-08-16 20:08:07

原文: http://blog.gqylpy.com/gqy/228

"

一、模块介绍

  1. multiprocess模快

    仔细说来,multiprocess不是一个模块,而是python中的一个操作、管理进程的包,之所以叫multi是取自multiple的多功能的意思,这个包中几乎包含了和进程有关的所有子模块。

  2. multiprocess.Process模块

    Process能够帮助我们创建子进程,以及对子进程的一些控制.

  • 参数:def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):

group=None:该参数未使用,值始终为None

target:指定要调用的函数,即子进程要执行的任务

args:指定被调用对象的位置参数,以元组的形式传入,必须有逗号,如:args=(‘a‘,);此参数在源码中定义的只接收元组,但由于tuple数据类型底层原理的原因,此参数是可以传入一切可迭代对象,如:列表、字典、字符串、生成器表达式等

kwargs:指定被调用对象关键字参数,以字典的形式传入,关键字作为键,参数作为值

name:指定子进程的名称,默认名称为:Process-1、Process-2、...

  • 方法

obj.start():启动子进程,并调用run()方法

obj.run():启动子进程时自动被调用,正是它去调用target参数指定的函数,自定义类中必须实现此方法

obj.terminate():强制终止子进程,不会进行任何清理操作,事实上是让操作系统去终止子进程;而操作系统终止进程是有一个过程的,所以子进程不会立即被终止;使用此方法需谨慎以下两种情况:1. 如果子进程中创建了子子进程,强制终止子进程后,子子进程将变成僵尸进程. 2. 如果子进程保存了一个锁,强制终止后,内存将不会被释放,进而导致死锁

obj.is_alive():判断子进程是否存活,若存活返回True,否则False

obj.join(timeout=None):阻塞父进程,等待子进程终止后再继续执行父进程,timeout指定等待超时时间;此方法只能用于使用start方法启动的子进程,对run方法启动的子进程无效

  • 属性

obj.daemon:默认值为False,如果设为True,子进程将成为守护进程,此属性必须写在start()的前面;守护进程无法创建子进程,且会随着父进程的终止而终止

obj.name:返回子进程的名称

obj.pid:返回子进程的pid

obj.exitcode:子进程在运行时为None,如果为-N,则表示被信号N结束了

obj.authkey:子进程的身份验证键,默认由os.urandom()随机成生成的32bytes;是为涉及网络连接的底层进程间通讯提供安全性,这类连接只有在具有相同身份验证键时才能成功


二、使用Process创建进程

  • windows系统使用Process模块需注意

    由于windows操作系统中没有fork(Linux操作系统中创建进程的机制),因此启动子进程时采用的是导入启动子进程的文件的方式来完成进程间的数据共享。而导入文件即等于执行文件,因此如果将process()直接写在文件中将会无限递归子进程而报错,所以必须把创建子进程的部分使用if __name__ == ‘__main__‘:判断保护起来,以防止递归.

1. 基本操作


  1. # 创建单个子进程及对子进程简单的控制
  2. from multiprocessing import Process
  3. from time import sleep
  4. import os
  5. def func(par):
  6. print("%s, PID: %s" %(par, os.getpid()))
  7. print("子进程终止后才继续执行父进程")
  8. sleep(5)
  9. if __name__ == ‘__main__‘:
  10. p = Process(target=func, args=("子进程",)) # 实例化一个子进程对象p
  11. # p.run() # run方法启动的子进程免疫join方法
  12. p.start() # 子进程进入就绪状态,等待操作系统调度
  13. print(p.is_alive()) # True: 子进程存活
  14. p.join(1) # 阻塞父进程,等待子进程终止,等待超时时间1s
  15. print(p.is_alive()) # False: 子进程终止
  16. print("父进程, PID: %s" % os.getpid())

  1. # 创建多个子进程
  2. from multiprocessing import Process
  3. from time import sleep
  4. def func(n):
  5. print("子进程", n)
  6. sleep(0.1)
  7. if __name__ == ‘__main__‘:
  8. p_lst = []
  9. for i in range(5): # 通过for循环启动多个子进程
  10. p = Process(target=func, args=(i,))
  11. p.start()
  12. p_lst.append(p)
  13. [p.join() for p in p_lst] # 阻塞父进程,等待所有子进程终止
  14. print("父进程")

2. 自定义多进程类


  1. # 自定义多进程类
  2. from multiprocessing import Process
  3. from time import sleep
  4. class MyProcess(Process):
  5. def __init__(self, target, name, sex):
  6. self.sex = sex
  7. super(MyProcess, self).__init__(target=target, name=name)
  8. # self.name = name
  9. # 父类Process初始化时会自动定义name属性,所以定义本类的name属性要写到super语句后面,
  10. # 否则会被父类初始化时覆盖掉(MyProcess-子进程序号),或者给父类传参__init__(name=name)
  11. def run(self): # 必写方法,用于调用函数
  12. print("子进程:", self.name)
  13. super(MyProcess, self).run()
  14. func = lambda :print("执行了函数")
  15. # 如果是Windows系统,此处要写一条__main__判断语句
  16. p = MyProcess(func, ‘zyk‘, ‘boy‘)
  17. p.start()
  18. # p.run() # start方法会自动调用此方法

3.进程之间的数据共享与隔离


  1. # 进程之间的数据共享与隔离
  2. from multiprocessing import Process, Value
  3. def func():
  4. global n # !
  5. n = 2 # 数据隔离:不会影响父进程中的变量n
  6. print("子进程n: ", n) # 2
  7. s.value = 4 # 数据共享:会影响父进程中的s
  8. print("子进程s: ", s.value)
  9. if __name__ == ‘__main__‘:
  10. n = 1
  11. s = Value(‘i‘, 3)
  12. p = Process(target=func)
  13. p.start()
  14. p.join()
  15. print("父进程n: ", n) # 1
  16. print("父进程s: ", s.value) # 4

4.守护进程


  1. # 守护进程
  2. from multiprocessing import Process
  3. from os import getpid
  4. class MyProcess(Process):
  5. def __init__(self, name):
  6. super(MyProcess, self).__init__()
  7. self.name = name
  8. def run(self):
  9. print(self.name, getpid())
  10. # 父进程是先进入就绪状态的,所以父进程一般会先终止(除非父进程还有很长的逻辑要走)
  11. # 子进程可能还未打印信息便随父进程终止而终止了,
  12. p = MyProcess(‘zyk‘)
  13. p.daemon = True # 确认为守护进程,随父进程终止而终止
  14. p.start()
  15. # p.join() # 阻塞父进程,方可正常执行完子进程,而显示打印信息
  16. print("父进程")

5.进阶:socket消息加并发实例


  1. # Server
  2. from multiprocessing import Process
  3. from socket import *
  4. server = socket(AF_INET, SOCK_STREAM)
  5. server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
  6. server.bind((‘127.0.0.1‘, 8080))
  7. server.listen(5)
  8. def talk(conn, client_addr):
  9. while True:
  10. try:
  11. msg = conn.recv(1472)
  12. if not msg:break
  13. conn.send(msg.upper())
  14. except Exception:
  15. break
  16. if __name__ == ‘__main__‘:
  17. while 1:
  18. conn, client_addr = server.accept()
  19. p = Process(target=talk, args=(conn, client_addr))
  20. p.start()
  21. print(p.name)

  1. # Client
  2. import socket
  3. client = socket.socket()
  4. client.connect_ex((‘127.0.0.1‘, 8080))
  5. while 1:
  6. msg = input(‘>>>‘).strip()
  7. if not msg:continue
  8. client.send(msg.encode(‘utf-8‘))
  9. msg = client.recv(1472)
  10. print(msg.decode(‘utf-8‘))

完结

"

原文: http://blog.gqylpy.com/gqy/228

原文地址:https://www.cnblogs.com/bbb001/p/11366093.html

时间: 2024-10-08 23:35:08

【Python 多进程】 -- 2019-08-16 20:08:07的相关文章

2014.08.16『转岗』『该来的,总得面对』

转岗申请的Email总算发出去了,心里长舒一口气,该来的,总得面对. 愿在阿里研究院的未来依然光明. 安全部,提前说再见了. 2014.08.16『转岗』『该来的,总得面对』,布布扣,bubuko.com

08.16号 dom 节点的创建 和删除DOM表单与非表单取值的方法 和操作属性与操作样式

<html> <head> <meta charset="utf-8"> <title>Dom操作</title> <script type="text/javascript" src="08.16/08.16.js"></script> </head> <body> <!--dom节点添加 删除 ; createElemen 创建一

Python 多进程多线编程模板

一.Python 多进程多线程原理介绍 1. Python 全局解释器锁GIL a) Python的全局解释器锁GIL是互斥锁,能够防止本机多个线程一次执行Python字节码:由于CPython的内存管理在线程级别是不安全的(内存泄露),所以这个全局解释器锁是必须的.每个Python进程只能申请使用一个GIL锁,因此Python的多线程虽然是并发的但不能并行处理.Python的解释器每次只能执行一个线程,待GIL锁释放后再执行下一个线程,这样线程轮流被执行. b) Python2.x里,GIL的

Python多进程使用

[Python之旅]第六篇(六):Python多进程使用 香飘叶子 2016-05-10 10:57:50 浏览190 评论0 python 多进程 多进程通信 摘要:   关于进程与线程的对比,下面的解释非常好的说明了这两者的区别:     这里主要说明关于Python多进程的下面几点: 1 2 3 4 5 6 7 1.多进程的使用方法 2.进程间的通信之multiprocessing.Manager()使用 3.Python进程池 ... 关于进程与线程的对比,下面的解释非常好的说明了这两者

【Python之旅】第六篇(六):Python多进程使用

关于进程与线程的对比,下面的解释非常好的说明了这两者的区别: 这里主要说明关于Python多进程的下面几点: 1.多进程的使用方法 2.进程间的通信 3.Python进程池 (1)比较简单的例子 (2)多个进程多次并发的情况 (3)验证apply.async方法是非阻塞的 (4)验证apply.async中的get()方法是阻塞的 1.多进程的使用方法 直接给出下面程序代码及注释: from multiprocessing import Process    #从多进程模块中导入Process

Python多进程(multiprocessing)学习总结

简介 multiprocessing模块使用和threading包类似的API接口来产生多进程,multiprocessing包提供本地和远程的并发,通过使用subprocesses(子进程)代替threads(线程)有效的避开了GIL(Global Interpreter Lock).由于这一点,multiprocessing模块允许程序充分的利用多处理器.可以跨平台使用,包括Unix和Windows!----https://docs.python.org/2/library/multipro

Python多进程multiprocessing(二)

紧接上文 在上文Python多进程multiprocessing(一)中我们介绍了多进程multiprocessing的部分基础操作,在本文中,我们将继续介绍关于多进程的一些知识,比如进程池Pool这个有用的东东.马上开始吧! 使用实例 实例1 import multiprocessing as mp def job(x): return x*x def multicore(): pool = mp.Pool(processes=2) res = pool.map(job,range(10))

Python多进程并发(multiprocessing)用法实例详解

http://www.jb51.net/article/67116.htm 本文实例讲述了Python多进程并发(multiprocessing)用法.分享给大家供大家参考.具体分析如下: 由于Python设计的限制(我说的是咱们常用的CPython).最多只能用满1个CPU核心.Python提供了非常好用的多进程包multiprocessing,你只需要定义一个函数,Python会替你完成其他所有事情.借助这个包,可以轻松完成从单进程到并发执行的转换. 1.新建单一进程 如果我们新建少量进程,

Python多进程(1)——subprocess与Popen()

Python多进程方面涉及的模块主要包括: subprocess:可以在当前程序中执行其他程序或命令: mmap:提供一种基于内存的进程间通信机制: multiprocessing:提供支持多处理器技术的多进程编程接口,并且接口的设计最大程度地保持了和threading模块的一致,便于理解和使用. 本文主要介绍 subprocess 模块及其提供的 Popen 类,以及如何使用该构造器在一个进程中创建新的子进程.此外,还会简要介绍 subprocess 模块提供的其他方法与属性,这些功能上虽然没

python多进程中使用pool

Python 多进程中使用pool,pool中指定每次运行几个进程,当其中一个进程结束完毕后,会加入新的进程 #!/usr/bin/env python #coding: utf-8 import multiprocessing import os,time,random def Lee(): print "Run task Lee-%s" %(os.getpid()) #os.getpid()获取当前的进程的ID start=time.time() time.sleep(random