python进阶多进程(进程池，进程间通信)

python 多进程

程序:是一个指令的集合

进程，正在执行的程序

编写完的代码，没有运行时，称为程序，正在运行的代码，称为进程
– 程序是死的(静态的)，进程是活的(动态的)

串行：  每个任务进入CPU中执行，执行一部分秒切下一个任务，处理完一个才能处理下一个，依次执行

并行：是指多个线程同时执行（多核CPU），微观上是同时的；

并发：一段时间内宏观上有多个序在同时运行，微观上这些程序都是交替执行的，（单核CPU）

多进程multiprocessing

多进程中， 每个进程中所有数据（包括全局变量） 都各有拥有⼀份， 互不影响

multiprocessing模块提供了⼀个Process类来创建⼀个进程对象

from multiprocessing import Process
def run(name):
	print("子进程运行中，name = %s"%(name))
if __name__ == "__main__": #在if __name__ == 'main': 下的代码只有在文件作为程序直接执行才会被执行，而import到其他程序中是不会被执行的
	print("父进程启动")
	p = Process(target=run, args=('test',))
#target表示调用对象，args表示调用对象的位置参数元组
#（注意：元组中只有一个元素时结尾要加，）
print("子进程将要执行")
p.start()
print(p.name) #p.pid
p.join()
print("子进程结束")

每次调用模块都会执行依次模块中全部内容，当你P对象建立的时候，会重新开辟一个新空间，导入主进程，会执行主进程当前模块所有内容，如果没有__nane__的就是递归调用模块，出错，有if __mian__的时候，子进程就不会运行

if __name__ == "__main__":

一个py文件有两种使用方法，一直接作为程序执行，二是import到其他的py程序中被调用执行

因此if __name__ == "__main__": 的作用就是控制这两种情况执行代码的过程 __name__是内置变量，用于当前模块的名字，所以if __name__ == "__main__":下的代码只有在文件作为程序直接执行才会执行，而import到其他文件不会执行。

在 Windows 上，子进程会自动 import 启动它的这个文件，而在 import 的时候是会执行这些语句的。
如果不加if __name__ == "__main__":的话就会无限递归创建子进程

Process类常⽤属性：

•Process(target , name , args）
•参数介绍

–target表示调用对象，即子进程要执行的任务 一般是函数名

–args表示调用对象的位置参数元组，args=(1,)

–name为子进程的名称

全局变量在多个进程中不共享：进程之间的数据是独立的，默认情况下互不影响

from multiprocessing import Process
num = 1
def run1():
	global num
	num += 5
	print("子进程1运行中，num = %d"%(num))
def run2():
	global num
	num += 10
	print("子进程2运行中，num = %d"%(num))
if __name__ == "__main__":
	print("父进程启动")
	p1 = Process(target=run1)
	p2 = Process(target=run2)
	print("子进程将要执行")
	p1.start()
	p2.start()
	p1.join()
	p2.join()
	print("子进程结束")
结果	
父进程启动
子进程将要执行
子进程1运行中，num = 6
子进程2运行中，num = 11
子进程结束

以上结果，如果不加join 主程序会在子程序运行前结束，程序运行，你会发现，全局变量按理说应该变化，但全局变量在多个进程中不共享：进程之间的数据是独立的，默认情况下互不影响的

类创建进程

创建新的进程还能够使⽤类的⽅式， 可以⾃定义⼀个类， 继承Process类， 每次实
例化这个类的时候， 就等同于实例化⼀个进程对象

import multiprocessing
import time
class ClockProcess(multiprocessing.Process):
	def run(self):
        n = 5
        while n > 0:
            print(n)
            time.sleep(1)
            n -= 1
if __name__ == '__main__':
    p = ClockProcess()
    p.start()
    p.join()

进程池：用来方便创建多个进程

⼿动的去创建进程的⼯作量巨⼤，此时就可以⽤到multiprocessing模块提供的Pool，初始化Pool时， 可以指定⼀个最⼤进程数， 当有新的请求提交到Pool中时，如果池还没有满， 那么就会创建⼀个新的进程⽤来执⾏该请求； 但如果池中的进程数已经达到指定的最⼤值， 那么该请求就会等待， 直到池中有进程结
束， 才会创建新的进程来执⾏

from multiprocessing import Pool
import random,time
def work(num):
    print(random.random()*num)
    time.sleep(2)
if __name__ == '__main__':
    po = Pool(5)        #定义一个进程池，最大进程数为5，如果不填写，默认CPU的核数
    for i in range(10): 循环创建子进程
        po.apply_async(work,(3,))#apply_async选择要调用的目标，每次循环会用空出来的子进程去调用目标
    po.close()#进程池关闭之后不再接收新的请求
    po.join()#等待po中所有子进程结束，必须放在close后面
    

multiprocessing.Pool常⽤函数解析：

–appy_async(func[, args[, kwds]]) ：使⽤⾮阻塞⽅式调⽤func（并⾏执⾏,堵塞⽅式必须等待上⼀个进程退出才能执⾏下⼀个进程） ， args为
传递给func的参数列表， kwds为传递给func的关键字参数列表；

–apply(func[, args[, kwds]])（了解即可） 使⽤阻塞⽅式调⽤func

–close()： 关闭Pool， 使其不再接受新的任务；

join()：主进程阻塞， 等待⼦进程的退出， 必须在close或terminate之后使⽤；

进程间通信-Queue

•多进程之间，默认是不共享数据的

•通过Queue（队列Q）可以实现进程间的数据传递

•Q本身是一个消息队列

•如何添加消息（入队操作）：

from multiprocessing import Queue
q = Queue(3)      #初始化一个Queue对象，最多可接受3条消息
q.put(“消息1”)     #添加的消息数据类型不限
q.put("消息2")
q.put("消息3")
print(q.full)

可以使⽤multiprocessing模块的Queue实现多进程之间的数据传递

•初始化Queue()对象时（例如： q=Queue()） ， 若括号中没有指定最⼤可接收的消息数量， 或数量为负值， 那么就代表可接受的消息数量没有上限

Queue.qsize()： 返回当前队列包含的消息数量

Queue.empty()： 如果队列为空， 返回True， 反之False

Queue.full()： 如果队列满了， 返回True,反之False

Queue.get([block[, timeout]])： 获取队列中的⼀条消息， 然后将其从列队
中移除， block默认值为True

• 如果block使⽤默认值， 且没有设置timeout（单位秒） ， 消息列队如果为空， 此时程序将被阻塞（停在读取状态） ， 直到从消息列队读到消息为⽌

• 如果设置了timeout， 则会等待timeout秒， 若还没读取到任何消息， 则抛出"Queue.Empty"异常

• 如果block值为False，消息列队如果为空， 则会⽴刻抛出“Queue.Empty”异常

from multiprocessing import Queue, Process
import time

def write(q):
    for value in ["a","b","c"]:
        print("开始写入：",value)
        q.put(value)
        time.sleep(1)

def read(q):
    while True:
        if not q.empty():
            print("读取到的是",q.get()) 
            time.sleep(1)
        else:
            break
if __name__ == "__main__":
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    pw.start()
    pw.join()#等待接收完毕
    pr.start()
    pr.join()
    print("接收完毕！")

进程池创建的进程之间的通信

进程池创建的进程之间通信：如果要使⽤Pool创建进程， 就需要使⽤multiprocessing.Manager()中的Queue() ⽽不是multiprocessing.Queue()

否则会得到⼀条如下的错误信息：RuntimeError: Queue objects should only be shared between processes through inheritance.

from multiprocessing import Manager,Pool
import time

def writer(q):

    for i in "we":
        print("开始写入",i)
        q.put(i)

def reader(q):
    time.sleep(3)
    for i in range(q.qsize()):
        print("得到消息",q.get())
if __name__ == "__main__":
    print("主进程启动")
    q = Manager().Queue()
    po = Pool(3)
    for i in range(5):
        po.apply_async(writer,(q,))
        po.apply_async(reader,(q,))
    po.close()
    po.join()

结果：主进程启动
开始写入 w
开始写入 e
开始写入 w
开始写入 e
开始写入 w
开始写入 e
得到消息 w
得到消息 e
得到消息 w
得到消息 e
得到消息 w
得到消息 e   #先按照池子规定的容量3，执行三次，然后执行完再往池子注入再执行后边的
开始写入 w
开始写入 e
得到消息 w
得到消息 e
开始写入 w
开始写入 e
得到消息 w
得到消息 e