python进阶之 并发编程
1.进程
顾名思义，进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。 进程的概念起源于操作系统，是操作系统最核心的概念，也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的。 即使可以利用的cpu只有一个（早期的计算机确实如此），也能保证支持（伪）并发的能力。将一个单独的cpu变成多个虚拟的cpu（多道技术：时间多路复用和空间多路复用+硬件上支持隔离），没有进程的抽象，现代计算机将不复存在。 进程的概念： 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是 操作系统动态执行的 基本单元，在传统的 操作系统中，进程既是基本的 分配单元，也是基本的执行单元。
2.cpu处理调度机制
SRE实战 互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。由此可知，本算法适合于CPU繁忙型作业，而不利于I/O繁忙型的作业（进程）。 FCFS调度算法的平均作业周转时间与作业提交的顺序和所需CPU时间有关 作业名 所需CPU时间 作业1 28 作业2 9 作业3 3 采用FCFS算法，三个作业的周转时间分别为：28、37和40，因此，平均作业周转时间T = (28+37+40)/3 = 35 若三个作业提交顺序改为作业2、1、3，平均作业周转时间约为29。 ((9+37+40)/3≈29) 若三个作业提交顺序改为作业3、2、1，平均作业周转时间约为18。 ((3+12+40)/3≈18)
短作业（进程）优先调度算法（SJ/PF）是指对短作业或短进程优先调度的算法，该算法既可用于作业调度，也可用于进程调度。但其对长作业不利；不能保证紧迫性作业（进程）被及时处理；作业的长短只是被估算出来的。
优点：
比FCFS改善平均周转时间和平均带权周转时间，缩短作业的等待时间；
提高系统的吞吐量；
缺点：
对长作业非常不利，可能长时间得不到执行；
未能依据作业的紧迫程度来划分执行的优先级；
难以准确估计作业（进程）的执行时间，从而影响调度性能。
时间片轮转(Round Robin，RR)算法的基本思路是让每个进程在就绪队列中的等待时间与享受服务的时间成比例。在时间片轮转法中，需要将CPU的处理时间分成固定大小的时间片，例如，几十毫秒至几百毫秒。如果一个进程在被调度选中之后用完了系统规定的时间片，但又未完成要求的任务，则它自行释放自己所占有的CPU而排到就绪队列的末尾，等待下一次调度。同时，进程调度程序又去调度当前就绪队列中的第一个进程。 显然，轮转法只能用来调度分配一些可以抢占的资源。这些可以抢占的资源可以随时被剥夺，而且可以将它们再分配给别的进程。CPU是可抢占资源的一种。但打印机等资源是不可抢占的。由于作业调度是对除了CPU之外的所有系统硬件资源的分配，其中包含有不可抢占资源，所以作业调度不使用轮转法。 在轮转法中，时间片长度的选取非常重要。首先，时间片长度的选择会直接影响到系统的开销和响应时间。如果时间片长度过短，则调度程序抢占处理机的次数增多。这将使进程上下文切换次数也大大增加，从而加重系统开销。反过来，如果时间片长度选择过长，例如，一个时间片能保证就绪队列中所需执行时间最长的进程能执行完毕，则轮转法变成了先来先服务法。时间片长度的选择是根据系统对响应时间的要求和就绪队列中所允许最大的进程数来确定的。 在轮转法中，加入到就绪队列的进程有3种情况： 一种是分给它的时间片用完，但进程还未完成，回到就绪队列的末尾等待下次调度去继续执行。 另一种情况是分给该进程的时间片并未用完，只是因为请求I/O或由于进程的互斥与同步关系而被阻塞。当阻塞解除之后再回到就绪队列。 第三种情况就是新创建进程进入就绪队列。 如果对这些进程区别对待，给予不同的优先级和时间片从直观上看，可以进一步改善系统服务质量和效率。例如，我们可把就绪队列按照进程到达就绪队列的类型和进程被阻塞时的阻塞原因分成不同的就绪队列，
每个队列按FCFS原则排列，各队列之间的进程享有不同的优先级，但同一队列内优先级相同。这样，当一个进程在执行完它的时间片之后，或从睡眠中被唤醒以及被创建之后，将进入不同的就绪队列。
1、设置 N 个就绪进程队列，即队列 0，队列 1，……，队列 N-1，用于存放就绪进程。每个队列 优先级不同，且从队列 0 到队列 N-1，优先级依次递减。 2、不同队列中的进程所赋予的时间片长度不同；优先级越低，时间片越长，比如，队列 0 中进程 的时间片为 5，队列 1 中进程的时间片为 10 等等。 3、在队列内部，进程之间采用先来先服务（FCFS）算法辅以时间片限时机制进行调度：位于队 列头部的进程（队首进程）先执行，如果在时间片限时内，它执行结束，则从本级队列移除；如 果它时间片内未能运行结束，则将它移入下一级队列末尾（若本级队列是最低优先级队列，则移 入本级队列末尾），然后按它当前所在新队列给它分配新的时间片。 4、当进程到达内存后，进入队列 0 末尾，并给它分配队列 0 规定的时间片。 5、优先执行高优先级队列中的队首进程，若高优先级队列中没有就绪进程，则执行下一级优先级 队列中的队首进程。 6、正在执行低优先级队列中的队首进程时，有新的进程到达高优先级队列，则立即中断低优先级 进程，并切换到高优先级进程执行。 https://blog.csdn.net/shenya1314/article/details/59077826
优点：
为提高系统吞吐量和缩短平均周转时间而照顾短进程。
为获得较好的I/O设备利用率和缩短响应时间而照顾I/O型进程。
不必估计进程的执行时间，动态调节
3.进程的并行与并发
并行:并行是指两者同时执行，比如赛跑，两个人都在不停的往前跑；（资源够用，比如三个线程，四核的CPU ）
并发:并发是指资源有限的情况下，两者交替轮流使用资源，比如一段路(单核CPU资源)同时只能过一个人，A走一段后，让给B，B用完继续给A ，交替使用，目的是提高效率。
区别:
并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器。
并发是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服务器同时处理多个session。
4.进程的5种状态
线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。 1.新建状态(New)： 当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码 2.就绪状态(Runnable) 一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。 处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。 3.运行状态(Running) 当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法. 4. 阻塞状态(Blocked) 线程运行过程中，可能由于各种原因进入阻塞状态: 1>线程通过调用sleep方法进入睡眠状态； 2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者； 3>线程试图得到一个锁，而该锁正被其他线程持有； 4>线程在等待某个触发条件； ...... 所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。 5. 死亡状态(Dead) 有两个原因会导致线程死亡： 1) run方法正常退出而自然死亡， 2) 一个未捕获的异常终止了run方法而使线程猝死。 为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false. 进程三种状态间的转换 一个进程在运行期间，不断地从一种状态转换到另一种状态，它可以多次处于就绪状态和执行状态，也可以多次处于阻塞状态。 A. 就绪—>执行 处于就绪状态的进程，当进程调度程序为之分配好了处理机后，该进程便由就绪状态转换为执行状态； B. 执行—>就绪 处于执行状态的进程在其执行过程中，因分配给它的一个时间片已经用完而不得不让出处理机，于是进程从执行状态转换为就绪状态； C. 执行—>阻塞 正在执行的进程因等待某种事件发生而无法继续执行时，便从执行状态变成阻塞状态； D. 阻塞—>就绪 处于阻塞状态的进程，若其等待的事件已经发生，于是进程便从阻塞状态转变为就绪状态。进程五种状态详解
5. python中进程操作
运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此，运行起来的python程序也是一个进程，那么我们也可以在程序中再创建进程。多个进程可以实现并发效果，也就是说，
当我们的程序中存在多个进程的时候，在某些时候，就会让程序的执行速度变快。
multiprocess包：
multiple：多功能的，包含了几乎所有和进程有关的子模
主要分为：创建进程部分，进程同步部分，进程持同步部分，进程之间数据共享
5.1 process模块介绍
Python中的multiprocess多进程包提供了Process类，实现进程相关的功能。但是它基于fork机制，因此不被windows平台支持。想要在windows中运行，必须使用if __name__ == '__main__:的方式，
显然这只能用于调试和学习，不能用于实际环境。另外，在multiprocess中你既可以import大写的Process，也可以import小写的process，这两者是完全不同的东西。
这种情况在Python中很多，请一定要小心和注意。
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字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）属性介绍
在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来，import 的时候 ，就不会递归运行了。在weindows中使用process模块的注意事项
5.2创建子进程并实现并发效果
import time import os from multiprocessing import Process def func (): time.sleep(1) print(1,os.getpid(),os.getppid()) if __name__ == '__main__': #异步执行func,在一秒钟的时间通过生成多个子进程来执行多个func #1.先实例化 #2.实例化对象.start() # 目标函数：target= Process(target=func).start() #process类通知操作系统要为当前代码快在开辟一个进程，是异步过程第一种方式
import time from multiprocessing import Process class Myprocess(Process): #继承Process类 def __init__(self,name): #重新父类的__init__方法 super().__init__() self.name =name def run(self): #必须是run函数名 print(os.getpid(),os.getppid(),'我爱你%s' % self.name) time.sleep(3) if __name__ == '__main__': start_time = time.time() p1 = Myprocess('kobe') p2 = Myprocess('kobe') p3 = Myprocess('kobe') p1.start() p2.start() p3.start() p1.join() #阻塞，直到p1对应的进程结束之后，才结束阻塞，是异步阻塞，阻塞等待一个子进程结束 p2.join() p3.join() print(time.time()-start_time) ##阻塞一个子进程：p.join() #阻塞多个子进程，将子进程加入到列表，然后分别阻塞 ''' 10600 9384 我爱你kobe 10448 9384 我爱你kobe 10032 9384 我爱你kobe 1.1659998893737793 从上面结果来看，我们知道join也是异步阻塞的，在同一秒钟分别执行了p1,p2,p3的time.sleep() 和我本来预想的要阻塞3s+是结果是不同的 '''继承Process类创建多进程
join方法：
p.join()阻塞，直到p对应的进程结束之后，才结束阻塞，是异步阻塞，阻塞等待一个子进程结束
import time import random from multiprocessing import Process def send_mail(name): time.sleep(random.uniform(1,3)) print('已经给%s发送邮件完毕'%name) if __name__ == '__main__': lst = ['kobe','jordan','admin','t-mac'] #阻塞等待一个子进程结束 p = Process(target=send_mail, args=('alex',)) p.start() p.join() # 阻塞,直到p对应的进程结束之后才结束阻塞 print('所有的信息都发送完毕了') #阻塞多个子进程，将子进程加入到列表，然后分别阻塞 p_l = [] for name in lst: p = Process(target=send_mail,args=(name,)) #args必须是元组类型 p.start() # p.join() #这种就是同步阻塞 p_l.append(p) for p in p_l : p.join() #异步阻塞 print('所有的信息都发送完毕了')join实例
5.3 守护进程
进程负责拿资源，线程负责执行任务
守护进程定义：
守护进程(daemon)是一类在后台运行的特殊进程，用于执行特定的系统任务。很多守护进程在系统引导的时候启动，并且一直运行直到系统关闭。另一些只在需要的时候才启动，完成任务后就自动结束
守护进程是可以一直运行而不阻塞主程序退出。要标志一个守护进程，可以将Process实例的daemon属性设置为True。
守护进程最大的特点是：子进程执行的过程中和主进程无关
#守护进程 #主进程结束 守护进程也结束 然后子进程结束 import time from multiprocessing import Process def func(): while True: # for i in range(20): time.sleep(0.5) print('in func') def func2(): print('start: func2') time.sleep(5) print('end: func2') if __name__ == '__main__': p = Process(target=func) p.daemon = True #表示设置p为一个守护进程 p.start() #结束主代码，结束 不管子进程 p2 = Process(target=func2) p2.start() print('in main') time.sleep(3) print('finished') # p.join() # 这样可以 子进程 。阻塞在这 可以等到子进程也结束 #为什么主进程要等待子进程结束之后再结束那？ #守护进程首先是子进程，守护的是主进程 #因为主进程要负责给子进程回收一些系统资源 #p.daemon= True #p.start() #守护进程的结束条件是主进程的代码全部结束之后再结束子进程,而不是等待主进程结束全部，因为主进程也要给守护进程回收资源 #将所有的进程都join住，守护进程就能在所有的子进程执行完毕之后再退出守护进程实例
返回系列
更多精彩
