并发编程之多进程知识

 并发编程之多进程

一 、multiprocessing模块介绍
       python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu_count()查看），在python中大部分情况需要使用多进程。Python提供了multiprocessing。
multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。
　   multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。
需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。

二、 Process类的介绍

创建进程的类：
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，
可用来开启一个子进程
强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

参数介绍：
group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称

方法介绍：
p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，
使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。
timeout是可选的超时时间。

属性介绍：
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程
终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid

三、Process类的使用
注意：在windows中Process()必须放到# if __name__ == '__main__':下
Since Windows has no fork, the multiprocessing module starts a new Python
process and imports the calling module.
If Process() gets called upon import, then this sets off an infinite succession of
new processes (or until your machine runs out of resources).
This is the reason for hiding calls to Process() inside

if __name__ == "__main__"
since statements inside this if-statement will not get called upon import.
由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。
如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。
这是隐藏对Process（）内部调用的原，使用if __name__ == “__main __”，这个if语句
中的语句将不会在导入时被调用。

创建并开启子进程的方式一

from multiprocessing import Process
import time


def task(name):
print('%s is running' % name)
time.sleep(3)
print('%s is done' % name)


if __name__ == '__main__':
# 实例化得到四个对象
p = Process(target=task, args=('子线程1',))
p2 = Process(target=task, args=('子线程2',))
p3 = Process(target=task, args=('子线程3',))
p4 = Process(target=task, args=('子线程4',))
# 调用对象下的方法，开启四个进程
p.start() # 仅仅是给操作系统发送一个信号
p2.start()
p3.start()
p4.start()
print('主进程')

创建并开启子进程的方式二

from multiprocessing import Process
import time


class MyProcess(Process):
def __init__(self,name):
super().__init__()
self.name = name

def run(self):
print('%s is running' % self.name)
time.sleep(3)
print('%s is done' % self.name)


if __name__ == '__main__':
# 实例化得到四个对象
p1 = MyProcess('子进程1')
p2 = MyProcess('子进程2')
p3 = MyProcess('子进程3')
p4 = MyProcess('子进程4')

p1.start() # start会自动调用run
p2.start()
p3.start()
p4.start()
print('主进程')

进程之间的内存空间是隔离的

from multiprocessing import Process
n = 100 # 在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了


def work():
global n
print('子进程内部：', n)


if __name__ == '__main__':
p = Process(target=work)
p.start()
print('主进程内部：', n)

查看进程与pid

from multiprocessing import Process
import os
import time


def task():
print('%s is running,parent id is %s' % (os.getpid(), os.getppid()))
time.sleep(3)
print('%s is done,parent id is %s' % (os.getpid(), os.getppid()))


if __name__ == '__main__':
p = Process(target=task,)
p.start()
print('主进程', os.getpid(), os.getppid())

四、join方法
在主进程运行过程中如果想要并发的执行其他任务，我们可以开启子进程，此时主进程的任务和子进程的任务分为两种情况

　　一种情况是：在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，然后统一回收资源

　　一种情况是：如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要一种机制能够让主进程监测子进程是否运行完

毕，在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用。

from multiprocessing import Process
import time
import os


def task():
print('%s is running,parent id is <%s>' % (os.getpid(), os.getppid()))
time.sleep(3)
print('%s is done,parent id is <%s>' % (os.getpid(), os.getppid()))


if __name__ == '__main__':
p = Process(target=task,)
p.start()

p.join()
print('主进程', os.getpid(), os.getppid())
print(p.pid)

join() 等待进程结束，是让主线程等待；
多任务多并发时，一个进程结束，另一个进程可能早已结束；理论上，jion花费的总时间是耗时间最长的那个进程运行的时间

五、Process对象的其他属性或方法

进程对象的其他方法一:terminate（关闭进程，不会立即关闭）与is_alive（查看进程是否存活，返回的是布尔类型）

from multiprocessing import Process
import time
import os


def task():
print('%s is running,parent id is <%s>' %(os.getpid(),os.getppid()))
time.sleep(3)
print('%s is done,parent id is <%s>' %(os.getpid(),os.getppid()))


def task1(name):
print('%s is running' % name)
time.sleep(3)
print('%s is done' % name)


if __name__ == '__main__':
p1 = Process(target=task1, args=('egon',), name='子进程1') # 可以用关键参数来指定进程名
p=Process(target=task,name='sub——Precsss')
p.start()
p1.start()
p.terminate() # 关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
time.sleep(1)
print(p.is_alive()) # 结果为False
print('主进程')
print(p.name)
print(p1.name, p1.pid,)

六、守护进程

主进程创建子进程，然后将该进程设置成守护自己的进程

特点:1.守护进程会在主进程代码执行结束后就终止
2.守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes
are not allowed to have children

如果我们有两个任务需要并发执行，可以开一个主进程和一个子线程，子线程应该在开启之前设置成守护进程，这样主程序运行结束，守护进程也终止了

from multiprocessing import Process
import time
import random


def task(name):
print('%s is running' % name)
time.sleep(random.randrange(1, 3))
print('%s is run done' % name)


if __name__ == '__main__':
p = Process(target=task, args=('egon',))
p.daemon = True # 一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
p.start()
print('主') # 只要终端打印出这一行内容，那么守护进程p也就跟着结束掉了

 

七、基于多进程实现的并发套接字通信
客户端

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))

while True:
msg=input('>>: ').strip()
if not msg:continue

client.send(msg.encode('utf-8'))
data=client.recv(1024)
print(data.decode('utf-8'))

服务端

from socket import *
from multiprocessing import Process

def talk(conn):
    while True:
        try:
            data = conn.recv(1024)
            if not data: break
            conn.send(data.upper())
        except ConnectionResetError:
            break

    conn.close()


def server(ip,port):
    server = socket(AF_INET, SOCK_STREAM)
    server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    server.bind((ip,port))
    server.listen(5)

    while True:
        conn, addr = server.accept()
        p = Process(target=talk, args=(conn,))
        p.start()

    server.close()


if __name__ == '__main__':
    server('127.0.0.1', 8080)

八、互斥锁
进程之间数据不共享，但是共享同一套文件系统，所以访问同一个文件，或者打印终端是没有问题的，但是带来的是竞争，竞争带来的结果是错乱，如下

# 并发运行,效率高,但竞争同一打印终端,带来了打印错乱
from multiprocessing import Process
import os, time


def work():
print ('%s is running' % os.getpid ())
time.sleep (2)
print ('%s is done' % os.getpid ())


if __name__ == '__main__':
for i in range (3):
p = Process (target=work)
p.start ()

如何控制，就是加锁处理。互斥锁的原理，就是把并发改成串行，降低了效率，但保证了数据安全不错乱

# 由并发变成了串行,牺牲了运行效率,但避免了竞争
from multiprocessing import Process,Lock
import os,time


def work(lock):
lock.acquire() # 加锁
print('%s is running' % os.getpid())
time.sleep(2)
print('%s is done' % os.getpid())
lock.release() # 释放锁


if __name__ == '__main__':
lock = Lock()
for i in range(3):
p = Process(target=work, args=(lock,))
p.start()

模拟抢票
使用互斥锁

# 文件db.txt的内容为：{"count":1} 注意一定要用双引号，不然json无法识别
from multiprocessing import Process,Lock
import json
import time

def search(name):
time.sleep(1)
dic=json.load(open('db.txt','r',encoding='utf-8'))
print('<%s> 查看到剩余票数【%s】' %(name,dic['count']))


def get(name):
time.sleep(1)
dic=json.load(open('db.txt','r',encoding='utf-8'))
if dic['count'] > 0:
dic['count']-=1
time.sleep(3)
json.dump(dic,open('db.txt','w',encoding='utf-8'))
print('<%s> 购票成功' %name)


def task(name,mutex):
search(name)
mutex.acquire()
get(name)
mutex.release()

if __name__ == '__main__':
mutex=Lock()
for i in range(10):
p=Process(target=task,args=('路人%s' %i,mutex))
p.start()

使用join方法

#把文件db.txt的内容重置为：{"count":1}
from multiprocessing import Process,Lock
import time,json

def search(name):
dic=json.load(open('db.txt'))
print('33[43m%s 查到剩余票数%s33[0m' %(name,dic['count']))

def get(name):
dic=json.load(open('db.txt'))
time.sleep(1) #模拟读数据的网络延迟
if dic['count'] >0:
dic['count']-=1
time.sleep(1) #模拟写数据的网络延迟
json.dump(dic,open('db.txt','w'))
print('33[46m%s 购票成功33[0m' %name)

def task(name,):
search(name)
get(name)

if __name__ == '__main__':
for i in range(10):
name='<路人%s>' %i
p=Process(target=task,args=(name,))
p.start()
p.join()

join是将一个任务整体串行，而互斥锁的好处则是可以将一个任务中的某一段代码串行

加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行地修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。

虽然可以用文件共享数据实现进程间通信，但问题是：

1、效率低（共享数据基于文件，而文件是硬盘上的数据）---->转换成 效率高
2、需要自己加锁处理 ---->处理好加锁问题

mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
队列和管道都是将数据存放于内存中，而队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，因而队列才是进程间通信的最佳选择。
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。

 

九、队列
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的

创建队列的类（底层就是以管道和锁定的方式实现）：
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，
可以使用Queue实现多进程之间的数据传递。

参数介绍：
maxsize是队列中允许最大项数，省略则无大小限制。
但需要明确：
1、队列内存放的是消息而非大数据
2、队列占用的是内存空间，因而maxsize即便是无大小限制也受限于内存大小

主要方法介绍：
q.put方法用以插入数据到队列中。
q.get方法可以从队列读取并且删除一个元素。

队列的使用：

from multiprocessing import Process,Queue

q=Queue(3)

#put ,get ,put_nowait,get_nowait,full,empty
q.put(1)
q.put(2)
q.put(3)
print(q.full()) #满了
# q.put(4) #再放就阻塞住了

print(q.get())
print(q.get())
print(q.get())
print(q.empty()) #空了
# print(q.get()) #再取就阻塞住了

十、生产者消费者模型
生产者指的是生产数据的任务，消费者指的是处理数据的任务，在并发编程中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

这个阻塞队列就是用来给生产者和消费者解开耦合的

from multiprocessing import Process,Queue
import time

def producer(q):
for i in range(10):
res='包子%s' %i
time.sleep(0.5)
print('生产者生产了%s' %res)

q.put(res)

def consumer(q):
while True:
res=q.get()
if res is None:break
time.sleep(1)
print('消费者吃了%s' % res)

 

if __name__ == '__main__':
#容器
q=Queue()

#生产者们
p1=Process(target=producer,args=(q,))
p2=Process(target=producer,args=(q,))
p3=Process(target=producer,args=(q,))

#消费者们
c1=Process(target=consumer,args=(q,))
c2=Process(target=consumer,args=(q,))

p1.start()
p2.start()
p3.start()
c1.start()
c2.start()

p1.join()
p2.join()
p3.join()
q.put(None)
q.put(None)
print('主')

JoinableQueue([maxsize])
这就像是一个Queue对象，但队列允许项目的使用者通知生成者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。

参数介绍
maxsize是队列中允许最大项数，省略则无大小限制。

方法介绍
JoinableQueue的实例p除了与Queue对象相同的方法之外还具有：
q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止

基于JoinableQueue实现生产者消费者模型

from multiprocessing import Process,JoinableQueue
import time

def producer(q):
for i in range(2):
res='包子%s' %i
time.sleep(0.5)
print('生产者生产了%s' %res)

q.put(res)
q.join()

def consumer(q):
while True:
res=q.get()
if res is None:break
time.sleep(1)
print('消费者吃了%s' % res)
q.task_done()


if __name__ == '__main__':
#容器
q=JoinableQueue()

#生产者们
p1=Process(target=producer,args=(q,))
p2=Process(target=producer,args=(q,))
p3=Process(target=producer,args=(q,))

#消费者们
c1=Process(target=consumer,args=(q,))
c2=Process(target=consumer,args=(q,))
c1.daemon=True
c2.daemon=True

p1.start()
p2.start()
p3.start()
c1.start()
c2.start()


p1.join()
p2.join()
p3.join()
#1、主进程等生产者p1、p2、p3结束
#2、而p1、p2、p3是在消费者把所有数据都取干净之后才会结束
#3、所以一旦p1、p2、p3结束了，证明消费者也没必要存在了，应该随着主进程一块死掉，因而需要将生产者们设置成守护进程
print('主')