Python 并发编程之多进程

一 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函数的位置参数，是一个元组形式，必须有逗号

参数介绍：
1.group参数未使用，值始终为None 
2.target表示调用对象，即子进程要执行的任务
3.args表示调用对象的位置参数元组，args=(1,2,'egon',)
4.kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
5.name为子进程的名称
方法介绍：
1.p.start()：启动进程，并调用该子进程中的p.run() 
2.p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  
3.p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
4.p.is_alive():如果p仍然运行，返回True
5.p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程 

属性介绍：
1.p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
2.p.name:进程的名称
3.p.pid：进程的pid
4.p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
5.p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

三 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 work(name):
    print('task <%s> is runing' %name)
    time.sleep(2)
    print('task <%s> is done' % name)

if __name__ == '__main__':
    # Process(target=work,kwargs={'name':'egon'})
    p1=Process(target=work,args=('egon',))
    p2=Process(target=work,args=('alex',))
    p1.start()
    p2.start()
    print('主')
#结果
主
task <李四> is runing
task <张三> is runing
task <李四> is done
task <张三> is done

创建并开启子进程的两种方式方法二：

from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print('task <%s> is runing' % self.name)
        time.sleep(2)
        print('task <%s> is done' % self.name)
if __name__ == '__main__':
    p1=MyProcess('张三')
    p1.start()
    p2=MyProcess('李四')
    p2.start()
    print('主')
#结果
主
task <李四> is runing
task <张三> is runing
task <李四> is done
task <张三> is done

Process对象的join方法：

from multiprocessing import Process
import time
def work(name):
    print('task <%s> is runing' %name)
    time.sleep(3)
    print('task <%s> is done' % name)

if __name__ == '__main__':
    p1=Process(target=work,args=('egon',))
    p2=Process(target=work,args=('alex',))
    p3=Process(target=work,args=('yuanhao',))
    #比较陋的方法
    p1.start()
    p2.start()
    p3.start()
    p1.join() #主进程等，等待p1运行结束
    p2.join() #主进程等，等待p2运行结束
    p3.join() #主进程等，等待p3运行结束
    #高大上的方式
    # p_l = [p1, p2, p3]
    # for p in p_l:
    #     p.start()
    # for p in p_l:
    #     p.join()

    print('主')

Process对象的其他方法或属性：

from multiprocessing import Process
import time,os
def work():
    print('parent:%s task <%s> is runing' %(os.getppid(),os.getpid()))
    time.sleep(5)
    print('parent:%s task <%s> is done'  %(os.getppid(),os.getpid()))

if __name__ == '__main__':
    p1=Process(target=work)
    p1.start()

    p1.terminate()
    time.sleep(3)
    print(p1.is_alive())
    print(p1.name)
    print(p1.pid)
    
    print('主',os.getpid(),os.getppid())
    time.sleep(5)

　　

四 守护进程

主进程创建守护进程：
　　其一：守护进程会在主进程代码执行结束后就终止
　　其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止

使用方法：　　

#主进程代码运行完毕,守护进程就会结束
from multiprocessing import Process
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")
if __name__ == '__main__':

    p1=Process(target=foo)
    p2=Process(target=bar)

    p1.daemon=True
    p1.start()
    p2.start()
    print("main-------") #打印该行则主进程代码结束,则守护进程p1应该被终止,可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止

五 进程同步(锁)

   进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,竞争带来的结果就是错乱，如何控制，就是加锁处理加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低
2.需要自己加锁处理
为此mutiprocessing模块为我们提供了基于消息的IPC通信机制：队列和管道。
1 队列和管道都是将数据存放于内存中
2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。

使用方法：

from multiprocessing import Process,Lock
import time
def work(name,mutex):
    mutex.acquire()
    print('task <%s> is runing' %name)
    time.sleep(2)
    print('task <%s> is done' % name)
    mutex.release()

if __name__ == '__main__':
    mutex=Lock()
    p1=Process(target=work,args=('张三',mutex))
    p2=Process(target=work,args=('李四',mutex))
    p1.start()
    p2.start()
    print('主')
#结果
主
task <李四> is runing
task <李四> is done
task <张三> is runing
task <张三> is done

现实模拟：多个进程共享同一文件，文件当数据库，模拟抢票：

文件模拟数据库：db.txt

{"count": 0}

程序：

import json
import os
import time
from multiprocessing import Process,Lock
def search():
    dic=json.load(open('db.txt'))
    print('\033[32m[%s] 看到剩余票数<%s>\033[0m' %(os.getpid(),dic['count']))
def get_ticket():
    dic = json.load(open('db.txt'))
    time.sleep(0.5) #模拟读数据库的网络延迟
    if dic['count'] > 0:
        dic['count']-=1
        time.sleep(0.5)  # 模拟写数据库的网络延迟
        json.dump(dic,open('db.txt','w'))
        print('\033[31m%s 购票成功\033[0m' %os.getpid())
def task(mutex):
    search()
    mutex.acquire()
    get_ticket()
    mutex.release()
if __name__ == '__main__':
    mutex=Lock()
    for i in range(10):
        p=Process(target=task,args=(mutex,))
        p.start()
#结果
[8560] 看到剩余票数<1>
[7032] 看到剩余票数<1>
[492] 看到剩余票数<1>
[8908] 看到剩余票数<1>
[3436] 看到剩余票数<1>
[8120] 看到剩余票数<1>
[6900] 看到剩余票数<1>
[5756] 看到剩余票数<1>
[7672] 看到剩余票数<1>
[8540] 看到剩余票数<1>
 8560 购票成功

六 共享数据

展望未来，基于消息传递的并发编程是大势所趋；
即便是使用线程，推荐做法也是将程序设计为大量独立的线程集合；
通过消息队列交换数据。这样极大地减少了对使用锁定和其他同步手段的需求；
还可以扩展到分布式系统中；
进程间通信应该尽量避免使用本节所讲的共享数据的方式；

进程间数据是独立的，可以借助于队列或管道实现通信，二者都是基于消息传递的
虽然进程间数据独立，但可以通过Manager实现数据共享，事实上Manager的功能远不止于此
A manager object returned by Manager() controls a server process which holds Python objects and allows other processes to manipulate them using proxies.
A manager returned by Manager() will support types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array. For example,

例：

from multiprocessing import Process,Manager,Lock
def task(dic,mutex):
    with mutex:
        dic['count']-=1
if __name__ == '__main__':
    mutex=Lock()
    m=Manager()
    dic=m.dict({'count':100})
    p_l=[]
    for i in range(100):
        p=Process(target=task,args=(dic,mutex))
        p_l.append(p)
        p.start()
    for p in p_l:
        p.join()
    print(dic)

#结果
{'count': 0}