python 并发之进程

一.什么是进程

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

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

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

　举例： 比如py1文件中有个变量a=1，py2文件中有个变量a=2，他们两个会冲突吗？不会的，是不是，因为两个文件运行起来后是两个进程，操作系统让他们在内存上隔离开，对吧。

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

　　狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
　　广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
　　举例： 比如py1文件中有个变量a=1，py2文件中有个变量a=2，他们两个会冲突吗？不会的，是不是，因为两个文件运行起来后是两个进程，操作系统让他们在内存上隔离开，对吧。

进程的概念

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

进程的特征

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
而进程是程序在处理机上的一次执行过程，它是一个动态的概念。
程序可以作为一种软件资料长期存在，而进程是有一定生命期的。
程序是永久的，进程是暂时的。
举例：就像qq一样，qq是我们安装在自己电脑上的客户端程序，其实就是一堆的代码文件，我们不运行qq，那么他就是一堆代码程序，当我们运行qq的时候，这些代码运行起来，就成为一个进程了。

进程与程序的区别

注意：同一个程序执行两次，就会在操作系统中出现两个进程，所以我们可以同时运行一个软件，分别做不同的事情也不会混乱。比如打开暴风影音，虽然都是同一个软件，但是一个可以播放米老鼠，一个可以播放唐老鸭。

 

 

二.并发和并发

通过进程之间的调度，也就是进程之间的切换，我们用户感知到的好像是两个视频文件同时在播放，或者音乐和游戏同时在进行，那就让我们来看一下什么叫做并发和并行

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

　　并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发，（并行也属于并发）

你是一个cpu，你同时谈了三个女朋友，每一个都可以是一个恋爱任务，你被这三个任务共享要玩出并发恋爱的效果，
应该是你先跟女友1去看电影，看了一会说：不好，我要拉肚子，然后跑去跟第二个女友吃饭，吃了一会说：那啥，我去趟洗手间，然后跑去跟女友3开了个房，然后在你的基友眼里，你就在和三个女友同时在一起玩。

单核cpu多进程并发举例

　　并行：并行：同时运行，只有具备多个cpu才能实现并行

将多个cpu必须成高速公路上的多个车道，进程就好比每个车道上行驶的车辆，并行就是说，大家在自己的车道上行驶，会不影响，同时在开车。这就是并行

多个cpu多个进程举例

三.同步\异步\阻塞\非阻塞

1.进程状态

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

　　（1）就绪(Ready)状态

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

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

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

　　　　事件请求：input、sleep、文件输入输出、recv、accept等

　　　　事件发生：sleep、input等完成了

　　　　时间片到了之后有回到就绪状态，这三个状态不断的在转换。

 

2.同步异步

所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。其实就是一个程序结束才执行另外一个程序，串行的，不一定两个程序就有依赖关系。阻塞和非阻塞这两个概念与程序（线程）等待消息通知(无所谓同步或者异步)时的状态有关。也就是说阻塞与非阻塞主要是程序（线程）等待消息通知时的状态角度来说的

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

比如我们去楼下的老家肉饼吃饭，饭点好了，取餐的时候发生了一些同步异步的事情。
同步：我们都站在队里等着取餐，前面有个人点了一份肉饼，后厨做了很久，但是由于同步机制，我们还是要站在队里等着前面那个人的肉饼做好取走，我们才往前走一步。
异步：我们点完餐之后，点餐员给了我们一个取餐号码，跟你说，你不用在这里排队等着，去找个地方坐着玩手机去吧，等饭做好了，我叫你。这种机制(等待别人通知)就是异步等待消息通知。在异步消息处理中，等待消息通知者(在这个例子中等着取餐的你)往往注册一个回调机制，在所等待的事件被触发时由触发机制(点餐员)通过某种机制(喊号，‘250号你的包子好了‘)找到等待该事件的人。

同步异步举例

3.阻塞与非阻塞

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

继续上面的那个例子，不论是排队还是使用号码等待通知，如果在这个等待的过程中，等待者除了等待消息通知之外不能做其它的事情，那么该机制就是阻塞的，表现在程序中,也就是该程序一直阻塞在该函数调用处不能继续往下执行。
相反，有的人喜欢在等待取餐的时候一边打游戏一边等待，这样的状态就是非阻塞的，因为他(等待者)没有阻塞在这个消息通知上，而是一边做自己的事情一边等待。阻塞的方法：input、time.sleep，socket中的recv、accept等等。

阻塞与非阻塞举例

4.同步/异步 与 阻塞和非阻塞

1. 同步阻塞形式

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

1. 异步阻塞形式

　　　　如果在排队取餐的人采用的是异步的方式去等待消息被触发（通知），也就是领了一张小纸条，假如在这段时间里他不能做其它的事情，就在那坐着等着，不能玩游戏等，那么很显然，这个人被阻塞在了这个等待的操作上面；

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

1. 同步非阻塞形式

　　　　实际上是效率低下的。

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

1. 异步非阻塞形式

　　　　效率更高，

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

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

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

四.进程的创建

　1.multiprocessing模块第一种创建进程方式

import time
from multiprocessing import Process

def f1():
    time.sleep(3)
    print('xxx')

def f2():
    time.sleep(3)
    print('sss')

# window系统下必须写main,因为windows系统创建子进程的方式决定的,开启一个子进程,这个子进程会copy一份主进程的所有代码,并且机制类似于import引入,这样就容易导致引入代码的时候,被引入的代码中的可执行程序被执行,导致递归开始进程,会报错

if __name__ == '__main__':
    p1 = Process(target=f1)
    p2 = Process(target=f2)
    p1.start()
    p2.start()

　　2.for循环创建进程

import time
from multiprocessing import Process

def f1(i):
    time.sleep(3)
    print(i)
if __name__ == '__main__':

    for i in range(20):
        p1 = Process(target=f1, args=(i,))
        p1.start()

　　3.multiprocessing模块第二种创建进程方式

from multiprocessing import Process

class MyProcess(Process):

    def __init__(self,n):
        super().__init__()  # 别忘了执行父类的init
        self.n = n

    def run(self):
        print('宝宝and%s不可告人的事情'%self.n)

if __name__ == '__main__':

    p1 = MyProcess('高望')
    p1.start()

　　4.join方法

 import time
 from multiprocessing import Process

 def f1():
     time.sleep(2)
     print('xxx')

 def f2():
     time.sleep(2)
     print('sss')

 if __name__ == '__main__':

     p1 = Process(target=f1,)

     p2 = Process(target=f2,)

     p1.start()
     p2.start()
     p1.join()  # 等待子进程p1执行完毕
     p2.join()  # 等待子进程p2执行完毕
     print('我要等待子进程')
     print('我是主进程!!!')

五.进程锁

通过刚刚的学习，我们千方百计实现了程序的异步，让多个任务可以同时在几个进程中并发处理，他们之间的运行没有顺序，一旦开启也不受我们控制。尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题：进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的，而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理。

多进程抢占输出资源，导致打印混乱的示例

import os
import time
import random
from multiprocessing import Process

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

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

# 看结果：通过结果可以看出两个问题：问题一：每个进程中work函数的第一个打印就不是按照我们for循环的0-4的顺序来打印的
#问题二：我们发现，每个work进程中有两个打印，但是我们看到所有进程中第一个打印的顺序为0-2-1-4-3，但是第二个打印没有按照这个顺序，变成了2-1-0-3-4，说明我们一个进程中的程序的执行顺序都混乱了。
#问题的解决方法，第二个问题加锁来解决，第一个问题是没有办法解决的，因为进程开到了内核，有操作系统来决定进程的调度，我们自己控制不了
# 0: 9560 is running
# 2: 13824 is running
# 1: 7476 is running
# 4: 11296 is running
# 3: 14364 is running

# 2:13824 is done
# 1:7476 is done
# 0:9560 is done
# 3:14364 is done
# 4:11296 is done

多进程抢占输出资源，导致打印混乱的示例

加锁版

 import time,json
 from multiprocessing import Process,Lock

 def show_t(i):
     f = open('ticket', mode='r',encoding='utf-8')
     dic = json.load(f)
     print('%s查询剩余票数为%s'%(i,dic['count']))
 def get_t(i,l1):
     l1.acquire()
     f = open('ticket', mode='r', encoding='utf-8')
     dic = json.load(f)
     if dic['count'] > 0:
         dic['count'] -= 1
         print('%s抢票成功'%i)
         time.sleep(0.2)
         f = open('ticket',mode= 'w',encoding='utf-8')
         json.dump(dic,f)
     else:
         print('没票了')
     l1.release()
 if __name__ == '__main__':
     l1 = Lock()
     for i in range(10):
         p1 = Process(target=show_t,args=(i,))
         p1.start()

     for i in range(10):
         p2 = Process(target=get_t,args=(i,l1))
         p2.start()

进程锁总结：

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

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

IPC通信机制（了解）：IPC是intent-Process Communication的缩写，含义为进程间通信或者跨进程通信，是指两个进程之间进行数据交换的过程。IPC不是某个系统所独有的，任何一个操作系统都需要有相应的IPC机制，
比如Windows上可以通过剪贴板、管道和邮槽等来进行进程间通信，而Linux上可以通过命名共享内容、信号量等来进行进程间通信。Android它也有自己的进程间通信方式，Android建构在Linux基础上，继承了一
部分Linux的通信方式。

六.守护进程

之前我们讲的子进程是不会随着主进程的结束而结束，子进程全部执行完之后，程序才结束，那么如果有一天我们的需求是我的主进程结束了，由我主进程创建的那些子进程必须跟着结束，怎么办？守护进程就来了！

　　　　主进程创建守护进程

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

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

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

 import time
 from multiprocessing import Process

 def f1():
     time.sleep(3)
     print('xxxx')

 def f2():
     time.sleep(5)
     print('我是普通子进程')

 if __name__ == '__main__':
     p1 =Process(target=f1,)
     p1.daemon = True  # 将该进程设置为守护进程,必须写在start之前,意思如果我的主进程代码运行结束了,你这个子进程不管运行到什么地方,都直接结束
     p1.start()
     # 开启一个普通的子进程来验证一下守护进程的结束只和主进程的代码运行结束有关系,而整个程序的结束需要主进程和普通的子进程的代码都运行结束才结束
     p2 = Process(target=f2,)
     p2.start()
     # 等待2号普通进程的结束,才继续执行下面主进程的代码
     # p2.join()
     # 守护进程会跟着父进程的代码运行结束,就结束
     print('我是主进程')

七.队列

1.基础队列

 from multiprocessing import Process,Queue
 q = Queue(3)  # 创建一个队列队形,队列长度为3,先进先出
 q.put(1)
 print('>>>>',q.qsize()) # 返回当前队列的内容长度
 print(q.full())
 q.put(2)
 print('>>>>',q.qsize())
 q.put(3)
 print(q.full())  # q.full()了解,因为这个东西不可靠,满了返回一个True,不满返回一个False
 # print('sss')
 # q.put(4)  # 放入数据的时候,如果队列满了,程序会在你put操作的地方阻塞
 try:
     q.put_nowait(4)  # 不阻塞程序,但是会报错queue.Full,可以通过捕获异常来进行其他的操作
 except:
     print('队列满了,玩别的去吧')

 print('xxx')

 print(q.get())
 print(q.get())
 print(q.get())
 print('是不是空了呀:',q.empty())  # q.empty()了解,因为这个东西不可靠,空了返回一个True,不空返回False
 q.put(4)
 print('是不是空了呀:',q.empty())   # True或者False,因为q在put数据的时候,有一个细微的延迟回一个False
 print(q.get())  # 如果队列空了,程序会在这个地方卡主,也就是阻塞程序
 try:
     q.put_nowait()  # queue.Empty
 except:
     print('队列空了,搞别的事情')

 print('队列拿完了')

2.队列之队列简单通信

from multiprocessing import Process,Queue

def f1(q):
    q.put('约吗?')

if __name__ == '__main__':
    q = Queue(3)
    p =Process(target=f1,args=(q,))
    p.start()

    son_p_msg = q.get()

    print('来自子进程的消息:',son_p_msg)

3.队列之生产者消费者模型

 import time
 from multiprocessing import Process,JoinableQueue

 # 生产者
 def producer(q):
     for i in range(10):
         time.sleep(0.7)
         s = '大包子%s号'%i
         print(s+'新鲜出炉')
         q.put(s)
     q.join() # 就等着task_done()信号的数量.和我put进去的数量想同时,才继续执行
     print('所有任务都被处理了,继续前行吧少年们')

 def consumer(q):
     while 1:
         time.sleep(0.2)
         baozi =q.get()

         print(baozi+'被吃了')
         q.task_done()  # 给队列发送一个取出的这个任务已经处理完毕的信号

 if __name__ == '__main__':
     q = JoinableQueue(10)
     pro_p = Process(target=producer,args=(q,))
     con_p = Process(target=consumer,args=(q,))
     pro_p.start()
     con_p.daemon = True  # 守护进程
     con_p.start()

     pro_p.join()
     print('主进程结束')