Python并发编程之多进程

一.必备基础知识

　　进程是什么?进程指的是一个正在进行的程序,进程是用来描述程序执行过程的虚拟概念.

　　进程的概念起源于操作系统,进程是操作系统最核心的概念,操作系统其他所有的概念都是围绕进程来的.

　　从进程的概念又可以引入一个概念就是操作系统,

为什么要有操作系统?

　　现代的计算机系统主要是由一个或者多个处理器,主存,硬盘,键盘,鼠标,显示器,打印机,网络接口及其他输入输出设备组成.

　　一般而言,现代计算机系统就一个复杂的系统.

　　其一:如果每位应用程序员都必须掌握该系统所有的细节,那就不可能再编写代码了,因为严重影响了程序员的开发效率,这些细节的掌握难度机器高

　　其二:管理这些部件并加以优化使用,是一件极富挑战性的工作,于是,计算机安装了一层软件,称为操作系统.它的任务就是为用户程序提供一个更好,更简单的计算机模型,并管理刚才提到的所有设备.

　　所以,程序员无法把所有的硬件操作细节都了解到,管理这些硬件并且加以优化使用是非常繁琐的工作,这个繁琐的工作就是操作系统来干的,有了他,程序员就从这些繁琐的工作中解脱出来,只需要考虑自己的应用软件的编写,应用软件直接使用操作系统提供的功能来间接使用硬件.

什么是操作系统?

　　精简的说,操作系统就是一个协调,管理和控制计算机硬件资源和软件资源的控制程序.操作系统的本质也是一个软件.

　　操作系统所处的位置如下:

　　

操作系统的两大功能:

　　一：隐藏了丑陋的硬件调用接口，为应用程序员提供调用硬件资源的更好，更简单，更清晰的模型（系统调用接口）。应用程序员有了这些接口后，就不用再考虑操作硬件的细节，专心开发自己的应用程序即可。
　　例如：操作系统提供了文件这个抽象概念，对文件的操作就是对磁盘的操作，有了文件我们无需再去考虑关于磁盘的读写控制（比如控制磁盘转动，移动磁头读写数据等细节），

　　二：将应用程序对硬件资源的竞态请求变得有序化
　　例如：很多应用软件其实是共享一套计算机硬件，比方说有可能有三个应用程序同时需要申请打印机来输出内容，那么a程序竞争到了打印机资源就打印，然后可能是b竞争到打印机资源，也可能是c，这就导致了无序，打印机可能打印一段a的内容然后又去打印c...,操作系统的一个功能就是将这种无序变得有序。

多道技术:

1.产生背景：针对单核，实现并发
ps：
 现在的主机一般是多核，那么每个核都会利用多道技术
有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
 cpu中的任意一个，具体由操作系统调度算法决定。

2.空间上的复用：如内存中同时有多道程序
3.时间上的复用：复用一个cpu的时间片
　　强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
　　才能保证下次切换回来时，能基于上次切走的位置继续运行　　

二.并发与并行

　　无论是并发还是并行,再用户看来都是同时运行的,不管是进程还是线程,都只是一个任务而已,真实干活的是cpu,cpu来坐这些任务,而cpu同一时刻只能执行一个任务

　　一.并发:是伪并行,就是看起来是同时运行.单cpu+多道技术就可以实现并发

　　二.并行:同时运行,只有具备多个cpu才能实现并行

　　　　单核下,可以利用多道技术,多核,每个核都可以利用多道技术

　　　　有四个核,五个任务,这样同一时间有四个任务被执行,假设分别被分配给了cpu1,cpu2,cpu3,cpu4

　　　　一旦任务一遇到了I/O就被迫中断执行,此时任务五就拿到cpu1的时间片去执行,这就是多核下的多道技术

　　　　而一旦任务一的I/O结束了,操作系统会重新调用它,可能被分配给四个cpu中的任意一个去执行

　　

三.进程的状态

　　tail -f access.log |grep '404'

　　执行程序tail，开启一个子进程，执行程序grep，开启另外一个子进程，两个进程之间基于管道'|'通讯，将tail的结果作为grep的输入。

　　进程grep在等待输入（即I/O）时的状态称为阻塞，此时grep命令都无法运行

　　其实在两种情况下会导致一个进程在逻辑上不能运行，

　　1. 进程挂起是自身原因，遇到I/O阻塞，便要让出CPU让其他进程去执行，这样保证CPU一直在工作

　　2. 与进程无关，是操作系统层面，可能会因为一个进程占用时间过多，或者优先级等原因，而调用其他的进程去使用CPU。

　　因而一个进程由三种状态

　　 

四.开启进程的两种方式

方式一:　

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

# 在windows系统上,开启子进程的操作必须放到if __name__ == '__main__':
if __name__ == '__main__':
    obj = Process(target=task,args=('Yven',))
    obj.start()#只是向操作系统发送了一个开启子进程的信号
    # time.sleep(1)
    print('主')

方式二:

from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self,name):
        super(MyProcess, self).__init__()
        self.name = name

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

# 在windows系统上,开启子进程的操作必须放到if __name__ == '__main__':
if __name__ == '__main__':
    obj = MyProcess('Yven')
    obj.start()#只是向操作系统发送了一个开启子进程的信号
    # time.sleep(1)
    print('主')

五.Process对象的join方法

　　join让主进程在原地等待,等待子进程运行完毕,不会影响子进程的执行

from multiprocessing import Process
import time
def task(name,n):
    print('%s is running'%name)
    time.sleep(n)
    print('%s is done'%name)

if __name__ == '__main__':

    p_l = []
    start = time.time()
    for i in range(1,4):
        p = Process(target=task,args=('子进程%s'%i,i))
        p_l.append(p)
        p.start()

    for p in p_l:
        p.join()
    print('主进程',(time.time()-start))

join方法案例

六.进程之间内存空间互相隔离

from multiprocessing import Process

n = 100
def task():
    global n
    n = 0
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()
    print(n)

七.进程对象其他相关属性与方法

from multiprocessing import Process,current_process
import time,os
def task():
    print('%s is runing father is %s'%(os.getpid(),os.getppid()))

    print('%s is done'%os.getpid())

if __name__ == '__main__':
    p = Process(target=task,name='子进程')
    print(p.name)
    p.start()
    p.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
    print(p.is_alive())#判断进程是否关闭,返回是True
    time.sleep(0.1)
    print(p.is_alive())#返回是False
    print('主进程',os.getpid(),os.getppid())

进程对象的terminate,is_alive方法和name属性

　　进程pid:每一个进程在操作系统内都有一个唯一的id号,称为pid

from multiprocessing import Process,current_process
import time
def task():
    print('%s is runing'%current_process().pid)
    time.sleep(3)
    print('%s is done'%current_process().pid)

if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    print('主进程',current_process().pid)

八.僵尸进程与孤儿进程

基本概念:

　　在unix/linux中,正常情况下,子进程都是通过父进程创建的,子进程再创建新的进程,子进程的结束和父进程的运行是一个异步过程,即父进程永远无法预测子进程到底什么时候结束.当一个进程完成它的工作之后,它的父进程需要调用wait()或者waitpid()系统调用取得子进程的终止状态.

　　孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程,孤儿进程将被init进程所收养,并由init进程对它们完成状态收集工作

　　僵尸进程:一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait()或waitpid()获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中.

问题及危害:

　　unix提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息， 就可以得到。这种机制就是: 在每个进程退出的时候,内核释放该进程所有的资源,包括打开的文件,占用的内存等。 但是仍然为其保留一定的信息(包括进程号the process ID,退出状态the termination status of the process,运行时间the amount of CPU time taken by the process等)。直到父进程通过wait / waitpid来取时才释放。 但这样就导致了问题，如果进程不调用wait / waitpid的话， 那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程. 此即为僵尸进程的危害，应当避免。
　　孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
　　任何一个子进程(init除外)在exit()之后，并非马上就消失掉，而是留下一个称为僵尸进程(Zombie)的数据结构，等待父进程处理。这是每个 子进程在结束时都要经过的阶段。如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是“Z”。如果父进程能及时 处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。  如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。
僵尸进程危害场景：
　　例如有个进程，它定期的产 生一个子进程，这个子进程需要做的事情很少，做完它该做的事情之后就退出了，因此这个子进程的生命周期很短，但是，父进程只管生成新的子进程，至于子进程 退出之后的事情，则一概不闻不问，这样，系统运行上一段时间之后，系统中就会存在很多的僵死进程，倘若用ps命令查看的话，就会看到很多状态为Z的进程。 严格地来说，僵死进程并不是问题的根源，罪魁祸首是产生出大量僵死进程的那个父进程。因此，当我们寻求如何消灭系统中大量的僵死进程时，答案就是把产生大 量僵死进程的那个元凶枪毙掉（也就是通过kill发送SIGTERM或者SIGKILL信号啦）。枪毙了元凶进程之后，它产生的僵死进程就变成了孤儿进 程，这些孤儿进程会被init进程接管，init进程会wait()这些孤儿进程，释放它们占用的系统进程表中的资源，这样，这些已经僵死的孤儿进程 就能瞑目而去了。

九.守护进程

主进程创建守护进程

　　其一：守护进程会在主进程代码执行结束后就终止

　　其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止

from multiprocessing import Process
import time

def task(name):
    print('old man %s alive'%name)
    time.sleep(1)
    print('old man %s is death'%name)

if __name__ == '__main__':
    p = Process(target=task,args=('Hwt',))
    p.daemon = True##一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
    p.start()
    time.sleep(1)
    print('King Yven is death...')

十.互斥锁

　　进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,

　　而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理

#文件db的内容为：{"count":1}
#注意一定要用双引号，不然json无法识别
from multiprocessing import Process,Lock
import time,json,random
def search():
    dic=json.load(open('db.txt'))
    print('\033[43m剩余票数%s\033[0m' %dic['count'])

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

def task(lock):
    search()
    get()
if __name__ == '__main__':
    lock=Lock()
    for i in range(100): #模拟并发100个客户端抢票
        p=Process(target=task,args=(lock,))
        p.start()

#文件db的内容为：{"count":1}
#注意一定要用双引号，不然json无法识别
from multiprocessing import Process,Lock
import time,json,random
def search():
    dic=json.load(open('db.txt'))
    print('\033[43m剩余票数%s\033[0m' %dic['count'])

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

def task(lock):
    search()
    lock.acquire()
    get()
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    for i in range(100): #模拟并发100个客户端抢票
        p=Process(target=task,args=(lock,))
        p.start()

 

加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的数据）
2.需要自己加锁处理

因此我们最好找寻一种解决方案能够兼顾：1、效率高（多个进程共享一块内存的数据）2、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
1 队列和管道都是将数据存放于内存中
2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性

 

十一.队列

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

　　创建队列的类(底层就是以管道和锁定的方式实现):

　　Queue([maxsize]):创建共享的进程队列,maxsize是队列中允许最大项数,省略则无大小限制

　　方法介绍:

 

1 q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
2 q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
3  
4 q.get_nowait():同q.get(False)
5 q.put_nowait():同q.put(False)
6 
7 q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
8 q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
9 q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样

了解方法
 q.cancel_join_thread():不会在进程退出时自动连接后台线程。可以防止join_thread()方法阻塞
2 q.close():关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。
3 q.join_thread()：连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为

 

　　代码实例:

'''
multiprocessing模块支持进程间通信的两种主要形式:管道和队列
都是基于消息传递实现的,但是队列接口
'''

from multiprocessing import Process,Queue
import time
q=Queue(3)


#put ,get ,put_nowait,get_nowait,full,empty
q.put(3)
q.put(3)
q.put(3)
print(q.full()) #满了

print(q.get())
print(q.get())
print(q.get())
print(q.empty()) #空了

十二.生产者消费者模型

生产者消费者模型

　　在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

　　在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

 什么是生产者消费者模式

　　生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

代码实例:

import time,random
from multiprocessing import Queue,Process
def producer(food,q):
    for i in range(3):
        res = '%s%s'%(food,i)
        time.sleep(random.randint(1,3))
        q.put(res)
        print('生产了%s'%res)

def consumer(name,q):
    while True:
        res = q.get()
        if res is None:break
        time.sleep(random.randint(1,3))
        print('%s吃了%s'%(name,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=('Yven',q))
    c2 = Process(target=consumer,args=('Hwt',q))
    p1.start()
    p2.start()
    p3.start()
    
    c1.start()
    c2.start()

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

 

　　上述代码也解决了主进程永远不会结束的问题,这个问题的原因是,生产者p在生产完后就结束了，但是消费者c在取空了q之后，则一直处于死循环中且卡在q.get()这一步。当然这个解决方式在有多个生产者和多个消费者时,会显得很low

　　其实我们的思路无非时发送结束信号而已,有另外一种队列提供了这种机制

 

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

#参数介绍：
maxsize是队列中允许最大项数，省略则无大小限制。    
#方法介绍：
JoinableQueue的实例p除了与Queue对象相同的方法之外还具有：
q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
q.join():生产者调用此

 

import time, random
from multiprocessing import  Process, JoinableQueue


def producer(food, q):
    for i in range(3):
        res = '%s%s' % (food, i)
        time.sleep(random.randint(1, 3))
        q.put(res)
        print('生产了%s' % res)


def consumer(name, q):
    while True:
        res = q.get()
        time.sleep(random.randint(1, 3))
        print('%s吃了%s' % (name, 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=('Yven', q))
    c2 = Process(target=consumer, args=('Hwt', q))
    c1.daemon = True
    c2.daemon = True

    p1.start()
    p2.start()
    p3.start()

    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()
    q.join()  # 主进程等q结束,即q内的数据被取干净了
    print('真香')