python-进程

什么是进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器，线程是程序的基本执行实体。程序是指令、数据及其组织形式的描述，进程是程序的实体。

狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。

广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。
文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。

第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。[3] 
进程是操作系统中最基本、重要的概念。是多道程序系统出现后，为了刻画系统内部出现的动态情况，描述系统内部各道程序的活动规律引进的一个概念,所有多道程序设计操作系统都建立在进程的基础上。

进程的概念

从理论角度看，是对正在运行的程序过程的抽象；
从实现角度看，是一种数据结构，目的在于清晰地刻画动态系统的内在规律，有效管理和调度进入计算机系统主存储器运行的程序。

动态性：进程的实质是程序在多道程序系统中的一次执行过程，进程是动态产生，动态消亡的。
并发性：任何进程都可以同其他进程一起并发执行
独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位；
异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进
结构特征：进程由程序、数据和进程控制块三部分组成。
多个不同的进程可以包含相同的程序：一个程序在不同的数据集里就构成不同的进程，能得到不同的结果；但是执行过程中，程序不能发生改变。

进程的特征

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
而进程是程序在处理机上的一次执行过程，它是一个动态的概念。
程序可以作为一种软件资料长期存在，而进程是有一定生命期的。
程序是永久的，进程是暂时的。

注意：同一个程序执行两次，就会在操作系统中出现两个进程，所以我们可以同时运行一个软件，分别做不同的事情也不会混乱。

进程调度

要想多个进程交替运行，操作系统必须对这些进程进行调度，这个调度也不是随机进行的，而是需要遵循一定的原则，由此就有了进程的调度算法。

先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。
FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。由此可知，本算法适合于CPU繁忙型作业，而不利于I/O繁忙型的作业（进程）。

短作业（进程）优先调度算法（SJ/PF）是指对短作业或短进程优先调度的算法，该算法既可用于作业调度，也可用于进程调度。
但其对长作业不利；不能保证紧迫性作业（进程）被及时处理；作业的长短只是被估算出来的。

时间片轮转(Round Robin，RR)法的基本思路是让每个进程在就绪队列中的等待时间与享受服务的时间成比例。
在时间片轮转法中，需要将CPU的处理时间分成固定大小的时间片，例如，几十毫秒至几百毫秒。
如果一个进程在被调度选中之后用完了系统规定的时间片，但又未完成要求的任务，
则它自行释放自己所占有的CPU而排到就绪队列的末尾，等待下一次调度。同时，进程调度程序又去调度当前就绪队列中的第一个进程。
      显然，轮转法只能用来调度分配一些可以抢占的资源。这些可以抢占的资源可以随时被剥夺，而且可以将它们再分配给别的进程。
CPU是可抢占资源的一种。但打印机等资源是不可抢占的。由于作业调度是对除了CPU之外的所有系统硬件资源的分配，其中包含有不可抢占资源，所以作业调度不使用轮转法。
在轮转法中，时间片长度的选取非常重要。首先，时间片长度的选择会直接影响到系统的开销和响应时间。
如果时间片长度过短，则调度程序抢占处理机的次数增多。这将使进程上下文切换次数也大大增加，从而加重系统开销。反过来，如果时间片长度选择过长，例如，一个时间片能保证就绪队列中所需执行时间最长的进程能执行完毕，则轮转法变成了先来先服务法。
时间片长度的选择是根据系统对响应时间的要求和就绪队列中所允许最大的进程数来确定的。
      在轮转法中，加入到就绪队列的进程有3种情况：
      一种是分给它的时间片用完，但进程还未完成，回到就绪队列的末尾等待下次调度去继续执行。
      另一种情况是分给该进程的时间片并未用完，只是因为请求I/O或由于进程的互斥与同步关系而被阻塞。当阻塞解除之后再回到就绪队列。
      第三种情况就是新创建进程进入就绪队列。
      如果对这些进程区别对待，给予不同的优先级和时间片从直观上看，可以进一步改善系统服务质量和效率。
例如，我们可把就绪队列按照进程到达就绪队列的类型和进程被阻塞时的阻塞原因分成不同的就绪队列，每个队列按FCFS原则排列，各队列之间的进程享有不同的优先级，但同一队列内优先级相同。
这样，当一个进程在执行完它的时间片之后，或从睡眠中被唤醒以及被创建之后，将进入不同的就绪队列。  

时间片轮转法

前面介绍的各种用作进程调度的算法都有一定的局限性。如短进程优先的调度算法，仅照顾了短进程而忽略了长进程，而且如果并未指明进程的长度，则短进程优先和基于进程长度的抢占式调度算法都将无法使用。
而多级反馈队列调度算法则不必事先知道各种进程所需的执行时间，而且还可以满足各种类型进程的需要，因而它是目前被公认的一种较好的进程调度算法。在采用多级反馈队列调度算法的系统中，调度算法的实施过程如下所述。
(1) 应设置多个就绪队列，并为各个队列赋予不同的优先级。第一个队列的优先级最高，第二个队列次之，其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。例如，第二个队列的时间片要比第一个队列的时间片长一倍，……，第i+1个队列的时间片要比第i个队列的时间片长一倍。
(2) 当一个新进程进入内存后，首先将它放入第一队列的末尾，按FCFS原则排队等待调度。当轮到该进程执行时，如它能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，……，如此下去，当一个长作业(进程)从第一队列依次降到第n队列后，在第n 队列便采取按时间片轮转的方式运行。

(3) 仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第1～(i-1)队列均空时，才会调度第i队列中的进程运行。如果处理机正在第i队列中为某进程服务时，又有新进程进入优先权较高的队列(第1～(i-1)中的任何一个队列)，则此时新进程将抢占正在运行进程的处理机，即由调度程序把正在运行的进程放回到第i队列的末尾，把处理机分配给新到的高优先权进程。

多级反馈队列

进程的并行与并发

并行 : 并行是指两者同时执行，比如有两条车道，在某一个时间点，两条车道上都有车在跑；（资源够用，比如三个线程，四核的CPU ）

并发 : 并发是指资源有限的情况下，两者交替轮流使用资源，比如只有一条车道(单核CPU资源)，那么就是A车先走，在某个时刻A车退出把道路让给B走，B走完继续给A ，交替使用，目的是提高效率。

区别:

并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器。
并发是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服务器同时处理多个session。

注意：早期单核CPU时候，对于进程也是微观上串行（站在cpu角度看），宏观上并行（站在人的角度看就是同时有很多程序在执行）。

同步异步阻塞非阻塞

状态介绍

　　在了解其他概念之前，我们首先要了解进程的几个状态。在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态：就绪，运行和阻塞。

　　（1）就绪(Ready)状态

　　当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。

　　（2）执行/运行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。

　　（3）阻塞(Blocked)状态正在执行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成（input）、申请缓冲区不能满足、等待信件(信号)等。

      

同步和异步

      所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。

　　所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。

阻塞与非阻塞

      阻塞和非阻塞这两个概念与程序（线程）等待消息通知(无所谓同步或者异步)时的状态有关。也就是说阻塞与非阻塞主要是程序（线程）等待消息通知时的状态角度来说的

同步/异步与阻塞/非阻塞

1. 同步阻塞形式

　　效率最低。拿上面的例子来说，就是你专心排队，什么别的事都不做。

2. 异步阻塞形式

　　如果在银行等待办理业务的人采用的是异步的方式去等待消息被触发（通知），也就是领了一张小纸条，假如在这段时间里他不能离开银行做其它的事情，那么很显然，这个人被阻塞在了这个等待的操作上面；

　　异步操作是可以被阻塞住的，只不过它不是在处理消息时阻塞，而是在等待消息通知时被阻塞。

3. 同步非阻塞形式

　　实际上是效率低下的。

　　想象一下你一边打着电话一边还需要抬头看到底队伍排到你了没有（两个操作不能同时执行，因为是同步），如果把打电话和观察排队的位置看成是程序的两个操作的话，这个程序需要在这两种不同的行为之间来回的切换，效率可想而知是低下的。

4. 异步非阻塞形式

　　效率更高，

　　因为打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不同的操作中来回切换。

　　比如说，这个人突然发觉自己烟瘾犯了，需要出去抽根烟，于是他告诉大堂经理说，排到我这个号码的时候麻烦到外面通知我一下，那么他就没有被阻塞在这个等待的操作上面，自然这个就是异步+非阻塞的方式了。

　　

很多人会把同步和阻塞混淆，是因为很多时候同步操作会以阻塞的形式表现出来，同样的，很多人也会把异步和非阻塞混淆，因为异步操作一般都不会在真正的IO操作处被阻塞。

在python程序中的进程操作

　　之前我们已经了解了很多进程相关的理论知识，了解进程是什么应该不再困难了，刚刚我们已经了解了，运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此，运行起来的python程序也是一个进程，那么我们也可以在程序中再创建进程。多个进程可以实现并发效果，也就是说，当我们的程序中存在多个进程的时候，在某些时候，就会让程序的执行速度变快。以我们之前所学的知识，并不能实现创建进程这个功能，所以我们就需要借助python中强大的模块。

multiprocessing模块

      仔细说来，multiprocessing不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多，为了方便大家归类记忆，我将这部分大致分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。

multiprocessing.process模块

process模块介绍

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():判断进程是否还活着,如果活着，返回True
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程  



方法介绍

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

属性介绍

使用process模块创建进程

在一个python进程中开启子进程，start方法和并发效果。

from multiprocessing import Process
import time
import os
############################################开启子进程的一种方式
# def func(i):
#     time.sleep(1)
#     print('这里是儿子进程,儿子自己的pid是%s,儿子的父进程的pid是%s'%(os.getpid(),os.getppid()))
#
# # os.getpid()获取的是当前进程自己的pid
# # os.getppid()获取的是当前进程的父进程的pid
# if __name__ == '__main__':
#     p = Process(target=func,args=(1,))# 实例化一个进程对象
  #target=  是子进程要执行的任务 #args= 是父进程给子进程传递的参数
#     p.start()# 开启一个子进程
#     print('这里是父亲进程，父进程自己的pid是：%s,父亲的父亲的pid是%s'%(os.getpid(),os.getppid()))

######################################### 开启子进程的另外一种方式，以继承的方式

# class MyProcess(Process):
#     def __init__(self):
#         super(MyProcess, self).__init__()
#     def run(self):
#         print('这是以继承类的方式开启的子进程')
#
# if __name__ == '__main__':
#     p1 = MyProcess()
#     p1.start()# 是指，解释器告诉操作系统，去帮我开启一个进程，   就绪状态
#     # p1.run()# 告诉操作系统，现在马上帮我执行这个子进程           执行


# class MyProcess(Process):
#     def __init__(self):
#         super(MyProcess, self).__init__()#  执行父类的__init__方法
#         # self.name = name
#
#     def run(self):
#         print('这是以继承类的方式开启的子进程,他的名字是%s'%self.name)
#
# if __name__ == '__main__':
#     p1 = MyProcess()
#     p1.start()# 是指，解释器告诉操作系统，去帮我开启一个进程，   就绪状态
        # 一般写start就行,start底层调用的就是run()
    # p1.run()# 告诉操作系统，现在马上帮我执行这个子进程           执行





#################################################如何开启多个不同的子进程

# def func(i):
#     time.sleep(1)
#     print('这里是儿子%s进程,儿子自己的pid是%s,儿子的父进程的pid是%s'%(i,os.getpid(),os.getppid()))
#
# # os.getpid()获取的是当前进程自己的pid
# # os.getppid()获取的是当前进程的父进程的pid
# if __name__ == '__main__':
#     for i in range(2):
#         p = Process(target=func,args=(i,))# 实例化一个进程对象
#         p.start()# 开启一个子进程
#     print('这里是父亲进程，父进程自己的pid是：%s,父亲的父亲的pid是%s'%(os.getpid(),os.getppid()))

from multiprocessing import Process
import time

def func():
    for i in range(500):
        time.sleep(0.01)
        print('儿子在这里')

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()# 是让主进程等待子进程执行完。  现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
    # time.sleep(1)
    for i in range(100):
        time.sleep(0.01)
        print('爸爸在这里')

# 开启一个正常的子进程，父进程会等待子进程结束后，父进程也就是程序才结束
# p.join()# 是让主进程等待子进程执行完。  现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
# 如何把父进程和子进程之间的关系变为同步或者异步？
# 父进程执行join，就会变成同步，不执行join，父进程和子进程就是异步的关系
# join必须放在start()后边

from multiprocessing import Process
import time


def func():
    time.sleep(1)
    print(123)


if __name__ == '__main__':
    p = Process(target=func,)
    p.start()
    p.terminate()# 杀死p进程,让解释器告诉操作系统，请杀掉p进程。
    print('子进程是否还活着？', p.is_alive())
    time.sleep(0.002)
    print('子进程是否还活着？', p.is_alive())
    # 返回一个bool值，如果返回True，代表进程还活着,如果返回False，代表子进程死了

# p.is_alive() 判断p进程是否还活着
# p.terminate() 杀死p进程

from multiprocessing import Process
import time
import os

def func():
    print('这里是儿子,儿子的pid是%s'%(os.getpid()))

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.name = 'alex'
    print('儿子的名字是%s'%p.name)
    print('儿子的pid是%s'%p.pid)
    print('儿子是不是守护进程？',p.daemon)

# from multiprocessing import Process
# import time
#
# def func():
#     time.sleep(100)
#     print('这里是儿子哦')
#
# if __name__ == '__main__':
#     p = Process(target=func)
#     p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
#     p.start()
#     time.sleep(1)
#     print('这是爸爸')
# 总结一下：
#     守护进程：跟随着父进程的代码执行结束，守护进程就结束

############################################守护进程的特点

# from multiprocessing import Process
# import time
#
# def func1():
#     print('这里是孙子')
#
# def func():
#     p = Process(target=func1)
#     p.start()
#     time.sleep(5)
#     print('这里是儿子哦')
#
# if __name__ == '__main__':
#     p = Process(target=func)
#     p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
#     p.start()
#     time.sleep(1)
#     print('这是爸爸')
#     守护进程：不允许开启子进程

#######################################  守护进程的用法
from multiprocessing import Process
import time


def func():
    for i in range(10):
        time.sleep(1)
        print(time.strftime('%H:%M:%S'))

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(5)
    print('这是爸爸')

守护进程                                                    

会随着父进程的结束而结束。

父进程创建守护进程

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

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

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

进阶，多个进程同时执行（注意：子进程的执行顺序并不受开启子进程的顺序影响）

from multiprocessing import Process
import time
import random

# def func(i):
#     print('我是%s'%i)
#
#
# if __name__ == '__main__':
#     l = []
#     addr = ['河南的','山东的','辽宁的','湖南的']
#     for i in addr:
#         p = Process(target=func,args=(i,))
#         p.start()
#         # p.join()
#         l.append(p)
#     [p.join() for p in l]
#     time.sleep(1)
#     print('我选%s'%(random.choice(addr)))

from multiprocessing import Process
def func(i):
    print('我是%s'%i)
    # global n
    # print(n)


if __name__ == '__main__':
    n = 100
    addr = ['河南的','山东的','辽宁的','湖南的']
    for i in addr:
        p = Process(target=func,args=(i,))
        p.start()

 实现多进程共享内存,这样会存在数据混乱的情况,看下面的银行存取钱的例子,关于银行存取款的问题。同一个账户，某个人一直存，某个人在同一时间一直取，如果不对数据进行保护起来，就会造成的一种数据混乱问题。

from multiprocessing import Process, Value


def get_money(num, l):  # 取钱

    for i in range(100):
        num.value -= 1
        print(num.value)
        time.sleep(0.01)



def put_money(num, l):  # 存钱

    for i in range(100):
        num.value += 1
        print(num.value)
        time.sleep(0.01)



if __name__ == '__main__':
    num = Value('i', 100)
    p = Process(target=get_money, args=(num, l))
    p.start()
    p1 = Process(target=put_money, args=(num, l))
    p1.start()
    p.join()
    p1.join()
    print(num.value)

进程同步(Lock、Semaphore、Event)

       在计算机中，有一些硬件和软件，例如处理器、打印机等，都属于竞争类资源，当有需求时，很多进程都要争抢这些资源，而对于这类资源，就属于临界资源。当多进程共同处理某一个数据时，这个数据也就属于一个临界资源。操作系统对计算机内各种资源都使其在竞争中有序化，但是对于数据来说，尤其是用户动态产生的数据，当处理时就变成了临界资源，所以我们作为程序猿来说，需要对临界资源加以保护，否则就会出现数据混乱现象。这是在提高程序效率的优势下，带来的一个隐患。

锁 —— Lock  

       通过刚刚的学习，我们千方百计实现了程序的异步，让多个任务可以同时在几个进程中并发处理，他们之间的运行没有顺序（或者说由操作系统调度决定他们的顺序），一旦开启也不受我们控制。尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题。

　　当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。

from multiprocessing import Process, Value, Lock
import time


def get_money(num, l):  # 取钱
    l.acquire()  # 拿走钥匙，锁上门，不允许其他人进屋
    for i in range(100):
        num.value -= 1
        print(num.value)
        time.sleep(0.01)
    l.release()  # 还钥匙，打开门，允许其他人进屋


def put_money(num, l):  # 存钱
    l.acquire()
    for i in range(100):
        num.value += 1
        print(num.value)
        time.sleep(0.01)
    l.release()


if __name__ == '__main__':
    num = Value('i', 100)
    l = Lock()
    p = Process(target=get_money, args=(num, l))
    p.start()
    p1 = Process(target=put_money, args=(num, l))
    p1.start()
    p.join()
    p1.join()
    print(num.value)

     上面这种情况，使用了加锁的形式确保了程序的顺序执行，但是执行又变成了串行，降低了效率，但是不得不说，它确保了数据的安全性。

      下面举例来说锁的重要性：模拟12306抢票问题。模拟银行账户的存取款问题。

# 注意，文件中存储需要以{'c':1}这种形式，c的引号一定要带
# 否则json识别不出来
# 此代码的效果，并发执行，但是多进程同时读写同一个文件数据，造成数据混乱

from multiprocessing import Process,Lock
import json
import time

def check(i,l):
    with open('a.txt','r',encoding='utf-8') as f:
        dic = json.load(f)
    print('第%s个人在查票，余票为%s' % (i, dic['c']))
    pay(i,l)

def pay(i,l):
    with open('a.txt','r',encoding='utf-8') as f:
        dic = json.load(f)
    time.sleep(0.5)# 模拟网络延迟，当购买过程中也会有网络延迟
    if dic['c']:
        print('第%s个人买到票了 '%i)
        dic['c'] -= 1
    else:
        print('第%s个人没买到票'%i)
    with open('a.txt','w') as f:
        json.dump(dic,f)

if __name__ == '__main__':
    l = Lock()
    for i in range(10):
        p = Process(target=check,args=(i+1,l))
        p.start()

多个人同时抢票

很明显，上述例子中，因为多进程同时对一个临界资源（a.txt文件）进行了读写操作，使文件内数据混乱，也造成了余票为1张，但是很多人都抢到票的假象。那就加锁来解决它吧

from multiprocessing import Process,Lock
import time

def check(i):
    with open('余票') as f:
        con = f.read()
    print('第%s个人查到余票还剩%s张'%(i,con))

def buy_ticket(i,l):
    l.acquire()# 拿钥匙，锁门
    with open('余票') as f:
        con = int(f.read())
        time.sleep(0.1)
    if con > 0:
        print('33[31m 第%s个人买到票了33[0m'%i)
        con -= 1
    else:
        print('33[32m 第%s个人没有买到票33[0m'%i)
    time.sleep(0.1)# 是指 买完票后，把余票数量重写写入数据库的时间延迟
    with open('余票','w') as f:
        f.write(str(con))
    l.release()# 还钥匙，开门

if __name__ == '__main__':
    l = Lock()
    for i in range(10):
        p_ch = Process(target=check,args=(i+1,))
        p_ch.start()
    for i in range(10):
        p_buy = Process(target=buy_ticket,args=(i+1,l))
        p_buy.start()

信号量 —— Semaphore（了解）      

上述讲的Lock，属于互斥锁，也就是一把钥匙配备一把锁，同时只允许锁住某一个数据。而信号量则是

一把锁配备多把钥匙，也就是说同时允许锁住多个数据。

from multiprocessing import Semaphore,Lock

# l = Lock()
# l.acquire()
# print(123)
# l.acquire()
# print(456)


# l = Semaphore(4)
#
# l.acquire()# 拿走1把钥匙，锁上门
# print(123)
# l.acquire()# 拿走1把钥匙，锁上门
# print(456)
# l.acquire()# 拿走1把钥匙，锁上门
# print(789)
# # l.release()
# l.acquire()# 拿走1把钥匙，锁上门
# print(120)

from multiprocessing import Process,Semaphore
import time
import random

def func(i,sem):
    sem.acquire()
    print('第%s个人进入小黑屋,拿了钥匙锁上门' % i)
    time.sleep(random.randint(3,5))
    print('第%s个人出去小黑屋,还了钥匙打开门' % i)
    sem.release()

if __name__ == '__main__':
    sem = Semaphore(5)# 初始化了一把锁5把钥匙，也就是说允许5个人同时进入小黑屋
    # 之后其他人必须等待，等有人从小黑屋出来，还了钥匙，才能允许后边的人进入
    for i in range(20):
        p = Process(target=func,args=(i,sem,))
        p.start()

事件 —— Event（了解） 

from multiprocessing import Event

e = Event()
# e.set()
# e.clear()
# e.wait()
# e.is_set()
# 事件是通过is_set()的bool值，去标识e.wait() 的阻塞状态
# 当is_set()的bool值为False时，e.wait()是阻塞状态
# 当is_set()的bool值为True时，e.wait()是非阻塞状态
# 当使用set()时，是把is_set的bool变为True
# 当使用clear()时，是把is_set的bool变为False

print(e.is_set())# False wait应该是阻塞住
e.set()# 将is_set 的bool值变为True，将wait变为非阻塞
e.wait()
print(e.is_set())
print(123)
e.clear()
print(e.is_set())
e.wait()
print(123)

from multiprocessing import Process,Event
import time
import random

def tra(e):
    '''信号灯函数'''
    # e.set()
    # print('33[32m 绿灯亮! 33[0m')
    while 1:# 红绿灯得一直亮着，要么是红灯要么是绿灯
        if e.is_set():# True,代表绿灯亮,那么此时代表可以过车
            time.sleep(5)# 所以在这让灯等5秒钟，这段时间让车过
            print('33[31m 红灯亮! 33[0m')# 绿灯亮了5秒后应该提示到红灯亮
            e.clear()# 把is_set设置为False
        else:
            time.sleep(5)# 此时代表红灯亮了，此时应该红灯亮5秒，在此等5秒
            print('33[32m 绿灯亮! 33[0m')# 红的亮够5秒后，该绿灯亮了
            e.set()# 将is_set设置为True

def Car(i,e):
    e.wait()# 车等在红绿灯，此时要看是红灯还是绿灯，如果is_set为True就是绿灯，此时可以过车
    print('第%s辆车过去了'%i)

if __name__ == '__main__':
    e = Event()
    triff_light = Process(target=tra,args=(e,))# 信号灯的进程
    triff_light.start()
    for i in range(50):# 描述50辆车的进程
        if i % 3 == 0:
            time.sleep(2)
        car = Process(target=Car,args=(i+1,e,))
        car.start()

进程间通信——队列和管道（Queue、Pipe）

 进程间通信--IPC（Inter-Process Communication）

IPC的方法：此处介绍队列和管道

队列                                                                   

概念：创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

Queue([maxsize]) 
创建共享的进程队列。
参数 ：maxsize是队列中允许存在的最大元素个数。如果省略此参数，则无大小限制。
底层队列使用管道和锁定实现。

     q = Queue(num)
       num ： 队列的最大长度
       q.get()# 阻塞等待获取数据，如果有数据直接获取，如果没有数据，阻塞等待
       q.put()# 阻塞，如果可以继续往队列中放数据，就直接放，不能放就阻塞等待

       q.get_nowait()# 不阻塞，如果有数据直接获取，没有数据就报错
       q.put_nowait()# 不阻塞，如果可以继续往队列中放数据，就直接放，不能放就报错

代码示例 

from multiprocessing import Queue

q = Queue(4)
q.put(1)
q.put(2)
q.put(3)
q.put(4)
# q.put(5) #如果是put，因为已经放满数据，所以程序会阻塞在put，等待取出数据
# q.put_nowait(5)　# 如果是put_nowait() ，不会阻塞，直接放入队列数据，队列满则报异常
try:
    q.put_nowait(5)# 在此处用try直接处理异常。此时数据不会放入到队列，会被直接丢弃
except:
    print('队列已满')

print(q.get())
print(q.get())
print(q.get())
print(q.get())
# print(q.get())# 此处和上边一样，因为队列中已空，所以程序会阻塞在get，等待放入数据
# q.get_nowait() # 不会阻塞，直接从队列中获取数据，获取不到则报错
try:
    q.get_nowait()# 在此处用try处理错误，此时获取不到数据，直接跳过
except:
    print('队列已空')

了解队列的用法

                    

生产者消费者模型                                  

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

举个应用栗子：全栈开发时候，前端接收客户请求，后端处理请求逻辑。当某时刻客户请求过于多的时候，后端处理不过来，此时完全可以借助队列来辅助，将客户请求放入队列中，后端逻辑代码处理完一批客户请求后马上从队列中继续获取，这样平衡两端的效率。

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

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

什么是生产者消费者模式

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

基于队列实现生产者消费者模型

from multiprocessing import Queue,Process
import time
import random

def get_func(q):
    while 1:
        time.sleep(random.randint(1, 3))
        info = q.get()
        print('33[32m张三拿走了%s 33[0m'%info)


def put_func(q):
    for i in range(20):
        info = '娃娃%s号'%i
        q.put(info)
        print('33[31m生产了%s 33[0m' % info)
        time.sleep(random.randint(1, 3))


if __name__ == '__main__':
    q = Queue(5)
    p_get = Process(target=get_func, args=(q,))
    p_put = Process(target=put_func, args=(q,))

    p_get.start()
    p_put.start()

队列的生产者消费者模型

 

 上述代码是基于队列实现的生产者消费者模型，生产者一直在生产娃娃，消费者一直在从队列中获取娃娃，但是消费者因为不知道生产者要生产多少娃娃，也不知道生产者何时就不生产了，所以消费者需要一个死循环一直尝试去从队列中获取娃娃，那么此时问题就出现了，3个进程，主进程开启了两个子进程分别为生产者和消费者，当生产者生产完数据后，生产者结束，消费者一直在尝试接收数据，那么问题就出在了消费者的get方法这里，当get不到数据时候就一直阻塞，那么主进程就一直等待，此时程序就不会结束了。

解决方法也很简单，可以尝试让生产者在生产完数据后，再往队列中放一个结束生产的信号，当消费者接受到信号后，自动的break出死循环即可。

# from multiprocessing import Queue,Process
# import time
#
# def consumer(q,name):
#     while 1:
#         info = q.get()
#         if info:
#             print('%s 拿走了%s'%(name,info))
#         else:# 当消费者获得队列中数据时，如果获得的是None，就是获得到了生产者不再生产数据的标识
#             break# 此时消费者结束即可
#
# # 消费者如何判断，生产者是没来得及生产数据，还是生产者不再生产数据了？
# # 如果你尝试用get_nowait() + try 的方式去尝试获得生产者不再生产数据，此时是有问题的。
#
# def producer(q,product):
#     for i in range(20):
#         info = product + '的娃娃%s号'%str(i)
#         q.put(info)
#     q.put(None)# 让生产者生产完数据后，给消费者一个不再生产数据的标识
#
# if __name__ == '__main__':
#     q = Queue(10)
#     p_pro = Process(target=producer,args=(q,'奥特曼'))
#     p_con = Process(target=consumer,args=(q,'张三'))
#     p_pro.start()
#     p_con.start()

from multiprocessing import Queue, Process
import time


def consumer(q, name):  # 消费者
    while 1:
        info = q.get()
        if info:
            print('%s拿走了%s' % (name, info))
        else:
            break


# 消费者如何判断生产者是没来的及生产数据，还是生产者不在生产数据了？

def producer(q, product):
    for i in range(20):
        info = product + '娃娃%s号' % str(i)
        q.put(info)


if __name__ == '__main__':
    q = Queue(10)
    p_con = Process(target=consumer, args=(q, '张三'))
    p_pro = Process(target=producer, args=(q, '哆啦A梦'))
    p_pro.start()
    p_con.start()
    p_pro.join()
    q.put(None)

from multiprocessing import Queue,Process
import time

def consumer(q,name,color):
    while 1:
        info = q.get()
        if info:
            print('%s %s 拿走了%s 33[0m'%(color,name,info))
        else:# 当消费者获得队列中数据时，如果获得的是None，就是获得到了生产者不再生产数据的标识
            break# 此时消费者结束即可

# 消费者如何判断，生产者是没来得及生产数据，还是生产者不再生产数据了？
# 如果你尝试用get_nowait() + try 的方式去尝试获得生产者不再生产数据，此时是有问题的。

def producer(q,product):
    for i in range(20):
        info = product + '的娃娃%s号'%str(i)
        q.put(info)

if __name__ == '__main__':
    q = Queue(10)
    p_pro1 = Process(target=producer,args=(q,'奥特曼'))
    p_pro2 = Process(target=producer,args=(q,'蜡笔小新'))
    p_pro3 = Process(target=producer,args=(q,'天选娃娃'))
    p_con1 = Process(target=consumer,args=(q,'张三','33[31m'))
    p_con2 = Process(target=consumer,args=(q,'李四','33[32m'))
    p_l = [p_con1,p_con2,p_pro1,p_pro2,p_pro3]
    [i.start() for i in p_l]
    # 父进程如何感知到生产者子进程不再生产数据了？
    p_pro1.join()
    p_pro2.join()
    p_pro3.join()
    q.put(None)# 几个消费者就要接受几个结束标识
    q.put(None)

JoinableQueue([maxsize]) 

 创建可连接的共享队列进程。它就好像一个Queue对象，但是它自带光环，允许消费者通知生产者是不是已经消费完所有的数据了。通知进程是使用共享的信号和条件变量来实现的。 

from multiprocessing import Process,JoinableQueue

q = JoinableQueue()

q.join()# 用于生产者。等待 q.task_done的返回结果，通过返回结果，生产者就能获得消费者当前消费了多少个数据
q.task_done() # 用于消费者，是指每消费队列中一个数据，就给join返回一个标识。

from multiprocessing import Process,JoinableQueue

q = JoinableQueue()

# q.join()# 用于生产者。等待 q.task_done的返回结果，通过返回结果，生产者就能获得消费者当前消费了多少个数据
# q.task_done() # 用于消费者，是指每消费队列中一个数据，就给join返回一个标识。

# 假设生产者生产了100个数据，join就能记录下100这个数字。每次消费者消费一个数据，就必须要task_done返回一个标识，当生产者（join）接收到100个消费者返回来的标识的时候，生产者就能知道消费者已经把所有数据都消费完了。

from multiprocessing import Queue,Process
import time

def consumer(q,name,color):
    while 1:
        info = q.get()
        print('%s %s 拿走了%s 33[0m'%(color,name,info))
        q.task_done()



def producer(q,product):
    for i in range(20):
        info = product + '的娃娃%s号'%str(i)
        q.put(info)
    q.join()# 记录了生产了20个数据在队列中,此时会阻塞等待消费者消费完队列中所有数据

if __name__ == '__main__':
    q = JoinableQueue(10)
    p_pro1 = Process(target=producer,args=(q,'奥利给'))
    p_con1 = Process(target=consumer,args=(q,'张三','33[31m'))
    p_con1.daemon = True# 把消费者进程设为守护进程
    p_con1.start()
    p_pro1.start()
    p_pro1.join()# 主进程等待生产者进程结束
    # 程序有3个进程，主进程和生产者进程和消费者进程。  当主进程执行到 p_pro1.join()代码时，主进程会等待生产进程结束
    # 而生产进程中 q.join()会等待消费者进程把所有数据消费完，生产者进程才结束。
    # 现在的状态就是  主进程等待生产者进程结束，生产者进程等待消费者消费完所有数据
    # 所以，把消费者设置为守护进程。  当主进程执行完，就代表生产进程已经结束，也就代表消费者进程已经把队列中数据消费完
    # 此时，主进程一旦结束，守护进程也就是消费者进程也就跟着结束。    整个程序也就能正常结束了。

管道(了解)

单进程下没人用管道

from multiprocessing import Pipe

# con1,con2 = Pipe()
#
# con1.send('abc')
# print(con2.recv())
# con2.send(123)
# print(con1.recv())

from multiprocessing import Pipe,Process

def func(con):
    con1,con2 = con
    con1.close()# 子进程使用con2和父进程通信，所以
    while 1:
        try:
            print(con2.recv())#当主进程的con1发数据时，子进程要死循环的去接收。
        except EOFError:# 如果主进程的con1发完数据并关闭con1，子进程的con2继续接收时，就会报错，使用try的方式，获取错误
            con2.close()# 获取到错误，就是指子进程已经把管道中所有数据都接收完了，所以用这种方式去关闭管道
            break

if __name__ == '__main__':
    con1,con2 = Pipe()
    p = Process(target=func,args=((con1,con2),))
    p.start()
    con2.close()# 在父进程中，使用con1去和子进程通信，所以不需要con2，就提前关闭
    for i in range(10):# 生产数据
        con1.send(i)# 给子进程的con2发送数据
    con1.close()# 生产完数据，关闭父进程这一端的管道

                                        

进程之间的数据共享            

进程间应该尽量避免通信，即便需要通信，也应该选择进程安全的工具来避免加锁带来的问题。以后我们会使用数据库来解决现在进程之间的数据共享问题。

 from multiprocessing import Manager,Value
       #m = Manager()
       #num = m.dict({键 : 值})
       #num = m.list([1,2,3])

def func(num):
    num[0] -= 1
    print('子进程中的num的值是',num)

if __name__ == '__main__':
    m = Manager()
    num = m.list([1,2,3])
    p = Process(target=func,args=(num,))
    p.start()
    p.join()
    print('父进程中的num的值是',num)

进程池--Pool    

为什么要有进程池?进程池的概念。

进程池：一个池子，里边有固定数量的进程。这些进程一直处于待命状态，一旦有任务来，马上就有进程去处理。
因为在实际业务中，任务量是有多有少的，如果任务量特别的多，不可能要开对应那么多的进程数
开启那么多进程首先就需要消耗大量的时间让操作系统来为你管理它。其次还需要消耗大量时间让
cpu帮你调度它。
进程池还会帮程序员去管理池中的进程。

p = Pool([numprocess  [,initializer [, initargs]]]):创建进程池

1 numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值
2 initializer：是每个工作进程启动时要执行的可调用对象，默认为None
3 initargs：是要传给initializer的参数组

       进程池Pool有三个方法：
        1. map(func,iterable)
         func：进程池中的进程执行的任务函数
         iterable: 可迭代对象，是把可迭代对象中的每个元素依次传给任务函数当参数

        2. apply(func,args=())： 同步的效率，也就是说池中的进程一个一个的去执行任务
         func：进程池中的进程执行的任务函数
         args: 可迭代对象型的参数，是传给任务函数的参数
         同步处理任务时，不需要close和join
         同步处理任务时，进程池中的所有进程是普通进程（主进程需要等待其执行结束）

        3. apply_async(func,args=(),callback=None)： 异步的效率，也就是说池中的进程一次性都去执行任务
         func：进程池中的进程执行的任务函数
         args: 可迭代对象型的参数，是传给任务函数的参数
         callback: 回调函数，就是说每当进程池中有进程处理完任务了，返回的结果可以交给回调函数，由回调函数进行进一步的处理,回调函数只有异步才有，同步是没有的
         异步处理任务时，进程池中的所有进程是守护进程（主进程代码执行完毕守护进程就结束）
         异步处理任务时，必须要加上close和join

         回调函数的使用：
             进程的任务函数的返回值，被当成回调函数的形参接收到，以此进行进一步的处理操作
             回调函数是由主进程调用的，而不是子进程，子进程只负责把结果传递给回调函数

import os
from multiprocessing import Pool,Process
import time



def func(num):
    num += 1
    print(num)


if __name__ == '__main__':
    p = Pool(os.cpu_count() + 1)
    start = time.time()
    p.map(func,[i for i in range(100)])
    p.close()# 指不允许在向进程池中添加任务
    p.join()# 等待进程池中所有进程执行完所有任务
    print('进程池做任务的效率：',time.time() - start)
    start = time.time()
    p_l = []
    for i in range(100):
        p1 = Process(target=func,args=(i,))
        p1.start()
        p_l.append(p1)
    [p1.join() for p1 in p_l]
    print('多进程直接做任务的效率',time.time() - start)
    # p.apply()是指让进程池中的进程，同步的帮你做任务
    # p.apply_async()# 是指让进程池中的进程，异步的帮你做任务

from multiprocessing import Pool


def func(num):
    num += 1
    print(num)
    return num

if __name__ == '__main__':
    p = Pool(5)
    res = p.map(func,[i for i in range(100)])
    p.close()
    p.join()
    print('主进程中map的返回值',res)

from multiprocessing import Pool
import time




def func(num):
    num += 1
    return num

if __name__ == '__main__':
    p = Pool(5)
    start = time.time()
    for i in range(10000):
        res = p.apply(func,args=(i,))# 同步处理这100个任务，同步是指，哪怕我进程中有5个进程，也依旧是1个进程1个进程的去执行任务
        # time.sleep(0.5)
        print(res)
    print(time.time() - start)

from multiprocessing import Pool
import time




def func(num):
    num += 1
    return num

if __name__ == '__main__':
    p = Pool(5)
    start = time.time()
    l = []
    for i in range(10000):
        res = p.apply_async(func,args=(i,))# 异步处理这100个任务，异步是指，进程中有5个进程，一下就处理5个任务，接下来哪个进程处理完任务了，就马上去接收下一个任务
        l.append(res)
    p.close()
    p.join()
    print(time.time() - start)
    # [print(i.get()) for i in l]

from multiprocessing import Pool
import requests
import time

def func(url):
    res = requests.get(url)
    print(res.text)
    if res.status_code == 200:
        return 'ok'

if __name__ == '__main__':
    p = Pool(5)
    l = ['https://www.baidu.com',
         'http://www.jd.com',
         'http://www.taobao.com',
         'http://www.mi.com',
         'http://www.cnblogs.com',
         'https://www.bilibili.com',
         ]
    start = time.time()
    for i in l:
        p.apply(func,args=(i,))

    apply_= time.time() - start

    start = time.time()
    for i in l:
        p.apply_async(func, args=(i,))
    p.close()
    p.join()
    print('同步的时间是%s，异步的时间是%s'%(apply_, time.time() - start))

from multiprocessing import Pool
import requests
import time,os

def func(url):
    res = requests.get(url)
    print('子进程的pid:%s,父进程的pid：%s'%(os.getpid(),os.getppid()))
    # print(res.text)
    if res.status_code == 200:
        return url,res.text

def cal_back(sta):
    url,text = sta
    print('回调函数的pid', os.getpid())
    with open('a.txt','a',encoding='utf-8') as f:
        f.write(url + text)
    # print('回调函数中！',url)

if __name__ == '__main__':
    p = Pool(5)
    l = ['https://www.baidu.com',
         'http://www.jd.com',
         'http://www.taobao.com',
         'http://www.mi.com',
         'http://www.cnblogs.com',
         'https://www.bilibili.com',
         ]
    print('主进程的pid',os.getpid())
    for i in l:
        p.apply_async(func, args=(i,),callback=cal_back)#
        # 异步执行任务func，每有一个进程执行完任务后，在func中return一个结果，结果会自动的被callback指定的函数，当成形式参数来接收到
    p.close()
    p.join()