企业网站托管排版设计,多用户购物商城源码,网络营销顾问服务,全国证书统一查询证书一、背景知识 顾名思义#xff0c;进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。进程的概念起源于操作系统#xff0c;是操作系统最核心的概念#xff0c;也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的…一、背景知识 顾名思义进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。进程的概念起源于操作系统是操作系统最核心的概念也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的。 PS即使可以利用的cpu只有一个早期的计算机确实如此也能保证支持伪并发的能力。将一个单独的cpu变成多个虚拟的cpu多道技术时间多路复用和空间多路复用硬件上支持隔离没有进程的抽象现代计算机将不复存在。 必备理论 #一 操作系统的作用1隐藏丑陋复杂的硬件接口提供良好的抽象接口2管理、调度进程并且将多个进程对硬件的竞争变得有序#二 多道技术 1.产生背景针对单核实现并发ps现在的主机一般是多核那么每个核都会利用多道技术有4个cpu运行于cpu1的某个程序遇到io阻塞会等到io结束再重新调度会被调度到4个cpu中的任意一个具体由操作系统调度算法决定。核心2.空间上的复用如内存中同时有多道程序3.时间上的复用复用一个cpu的时间片强调遇到io切占用cpu时间过长也切核心在于切之前将进程的状态保存下来这样才能保证下次切换回来时能基于上次切走的位置继续运行 二、多进程概念 1、进程正在进行的一个过程或者说一个任务。而负责执行任务则是cpu。进程有如下三个状态 其实在两种情况下会导致一个进程在逻辑上不能运行 1. 进程挂起是自身原因遇到I/O阻塞便要让出CPU让其他进程去执行这样保证CPU一直在工作 2. 与进程无关是操作系统层面可能会因为一个进程占用时间过多或者优先级等原因而调用其他的进程去使用CPU。 2、进程与程序的区别程序仅仅只是一堆代码而已而进程指的是程序的运行过程。 强调同一个程序执行两次那也是两个进程比如打开网易云音乐虽然都是同一个软件但是一个可以播放音乐一个可以播放mv。 举例单核多道实现多个进程的并发执行egon在一个时间段内有很多任务要做python备课的任务写书的任务交女朋友的任务王者荣耀上分的任务 但egon同一时刻只能做一个任务cpu同一时间只能干一个活如何才能玩出多个任务并发执行的效果egon备一会课再去跟李杰的女朋友聊聊天再去打一会王者荣耀....这就保证了每个任务都在进行中 3、并发与并行 无论是并行还是并发在用户看来都是同时运行的不管是进程还是线程都只是一个任务而已真是干活的是cpucpu来做这些任务而一个cpu同一时刻只能执行一个任务 并发针对只有一个cpu执行多个进程的情况。是伪并行即看起来是同时运行。单个cpu多道技术就可以实现并发。 并行针对多个cpu执行多个进程的情况并行也属于并发。 单核下可以利用多道技术多个核每个核也都可以利用多道技术多道技术是针对单核而言的 有四个核六个任务这样同一时间有四个任务被执行假设分别被分配给了cpu1cpu2cpu3cpu4 一旦任务1遇到I/O就被迫中断执行此时任务5就拿到cpu1的时间片去执行这就是单核下的多道技术 而一旦任务1的I/O结束了操作系统会重新调用它(需知进程的调度、分配给哪个cpu运行由操作系统说了算)可能被分配给四个cpu中的任意一个去执行 三、同步\异步and阻塞\非阻塞 同步是指发送方发出数据后等接收方发回响应以后才发下一个数据包的通讯方式。 异步是指发送方发出数据后不等接收方发回响应接着发送下个数据包的通讯方式。 同步 #所谓同步就是在发出一个功能调用时在没有得到结果之前该调用就不会返回。 按照这个定义其实绝大多数函数都是同步调用。但是一般而言我们在说同步、异步的时候特指那些需要其他部件协作或者需要一定时间完成的任务。
#举例
#1. multiprocessing.Pool下的apply #发起同步调用后就在原地等着任务结束根本不考虑任务是在计算还是在io阻塞总之就是一股脑地等任务结束
#2. concurrent.futures.ProcessPoolExecutor().submit(func,).result()
#3. concurrent.futures.ThreadPoolExecutor().submit(func,).result() 异步 #异步的概念和同步相对。当一个异步功能调用发出后调用者不能立刻得到结果。当该异步功能完成后通过状态、通知或回调来通知调用者。 如果异步功能用状态来通知那么调用者就需要每隔一定时间检查一次效率就很低有些初学多线程编程的人总喜欢用一个循环去检查某个变量的值这其实是一 种很严重的错误。 如果是使用通知的方式效率则很高因为异步功能几乎不需要做额外的操作。至于回调函数其实和通知没太多区别。
#举例
#1. multiprocessing.Pool().apply_async() #发起异步调用后并不会等待任务结束才返回相反会立即获取一个临时结果并不是最终的结果可能是封装好的一个对象。
#2. concurrent.futures.ProcessPoolExecutor(3).submit(func,)
#3. concurrent.futures.ThreadPoolExecutor(3).submit(func,) 阻塞 #阻塞调用是指调用结果返回之前当前线程会被挂起如遇到io操作。函数只有在得到结果之后才会将阻塞的线程激活。有人也许会把阻塞调用和同步调用等同起来实际上他是不同的。对于同步调用来说很多时候当前线程还是激活的只是从逻辑上当前函数没有返回而已。
#举例
#1. 同步调用apply一个累计1亿次的任务该调用会一直等待直到任务返回结果为止但并未阻塞住即便是被抢走cpu的执行权限那也是处于就绪态;
#2. 阻塞调用当socket工作在阻塞模式的时候如果没有数据的情况下调用recv函数则当前线程就会被挂起直到有数据为止。 非阻塞 #非阻塞和阻塞的概念相对应指在不能立刻得到结果之前也会立刻返回同时该函数不会阻塞当前线程。 小结 #1. 同步与异步针对的是函数/任务的调用方式同步就是当一个进程发起一个函数任务调用的时候一直等到函数任务完成而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数任务调用的时候不会等函数返回而是继续往下执行当函数返回的时候通过状态、通知、事件等方式通知进程任务完成。#2. 阻塞与非阻塞针对的是进程或线程阻塞是当请求不能满足的时候就将进程挂起而非阻塞则不会阻塞当前进程 四、多进程实现 1、multiprocessing模块介绍 Python提供了multiprocessing。multiprocessing模块用来开启子进程并在子进程中执行我们定制的任务比如函数该模块与多线程模块threading的编程接口类似。 multiprocessing模块的功能众多支持子进程、通信和共享数据、执行不同形式的同步提供了Process、Queue、Pipe、Lock等组件。 需要再次强调的一点是与线程不同进程没有任何共享状态进程修改的数据改动仅限于该进程内。 2、Process类介绍为创建进程的类 主要方法 #p为子进程p.start()启动进程并调用该子进程中的p.run()
p.run():进程启动时运行的方法正是它去调用target指定的函数我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p不会进行任何清理操作如果p创建了子进程该子进程就成了僵尸进程使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放进而导致死锁
p.is_alive():如果p仍然运行返回True
p.join([timeout]):主线程等待p终止强调是主线程处于等的状态而p是处于运行的状态。timeout是可选的超时时间需要强调的是p.join只能join住start开启的进程而不能join住run开启的进程 主要属性 #p为子进程
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字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性这类连接只有在具有相同的身份验证键时才能成功了解即可 3、创建并开启子进程 方式一常用 from multiprocessing import Process
import timedef task(name):print(%s is running %name)time.sleep(2)if __name__ __main__: #在windows系统下开子进程的代码必须写到这一行下面pProcess(targettask,args(egon,))p.start() #只是在给操作系统发了一个信号让操作系统去开进程申请内存拷贝父进程的地址空间print(主) from multiprocessing import Process
import time
def work(name):print(%s is piaoing %name)time.sleep(5)print(%s piao end %name)
if __name____main__: #windows系统必须加pProcess(targetwork,args(egon,))#args传参必须是个元组括号内要加逗号只是在给操作系统发一个信号让操作系统去开进程# # 申请内存拷贝父进程的地址空间 p干的活是work 也可以以字典形式传kwargs{name:egon}p.start()print(主进程) 方式二run 名字是固定的 # multi 多 process进程
from multiprocessing import Process
import timeclass Myprocess(Process): # 自己的类def __init__(self,name):super().__init__() # 保证有父类的功能self.namenamedef run(self):print(%s is running % self.name)time.sleep(2)if __name__ __main__:p Myprocess(egon)p.start() # 调的是p.run()print(主) from multiprocessing import Process
import time
class work(Process):def __init__(self,name):super(work, self).__init__() # super括号内的参数可以不用传保证有父类的功能self.namenamedef run(self): #方法名run()不可以更换print(%s is piaoing %self.name)time.sleep(5)print(%s piao end %self.name)
if __name____main__: #windows系统必须加pwork(egon)p.start() # 调的是p.run()print(主进程) 为什么python运行的程序在系统是python.exe python3 test.py ---- python.exe 当前进程ID : print(os.getpid()) 解释器pycharm(运行python)的进程id : print(os.getppid()) | 为管道符在cmd输tasklist 是全部运行的进程tasklist |findstr python 过滤出python 注意进程的直接内存空间是彼此隔离的如下例 from multiprocessing import Process
n100 #在windows系统中应该把全局变量定义在if __name__ __main__之上
def work():global nn0print(子进程内: ,n)
if __name__ __main__:pProcess(targetwork)p.start() #结果总为0print(主进程内: ,n) #结果总为100 4、socket并发编程实例 可以实现多个客户端与服务端进行交流。 服务端 from socket import *
from multiprocessing import Processserversocket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind((127.0.0.1,8080))
server.listen(5)def talk(conn):while True:try:msgconn.recv(1024)if not msg:breakconn.send(msg.upper())except Exception:breakif __name__ __main__:while True:conn,client_addrserver.accept()pProcess(targettalk,args(conn,))p.start() 客户端 #多个客户端
from socket import *
clientsocket(AF_INET,SOCK_STREAM)
client.connect((127.0.0.1,8080))
while True:msginput(: ).strip()if not msg:continueclient.send(msg.encode(utf-8))msgclient.recv(1024)print(msg.decode(utf-8)) 将进程干死terminate 5、jion()方法详解 join方法的主要作用是等待子进程结束后执行主进程。 基于谁开的子进程谁来关 标准版
from multiprocessing import Process
import time,random
def func(name):print(%s is running% name)time.sleep(random.randint(1,3))print(%s is runend% name)if __name__ __main__:p1 Process(targetfunc ,args(egon,))p2 Process(targetfunc ,args(alex,))p3 Process(targetfunc ,args(lishi,))p4 Process(targetfunc ,args(jassin,))p1.start()p2.start()p3.start()p4.start()print(zhu)# 精简版
from multiprocessing import Process
import time,randomdef piao(name):print(%s is piaoing %name)time.sleep(random.randint(1,3))print(%s is done %name)if __name__ __main__:p1 Process(targetpiao, args(alex,))p2 Process(targetpiao, args(wxx,))p3 Process(targetpiao, args(yxx,))p_l [p1, p2, p3]for p in p_l:p.start()for p in p_l:p.join()print(主) 并行效果 from multiprocessing import Process
import time
def piao(name):print(%s is piaoing %name)time.sleep(3)print(%s is piao end %name)
if __name____main__:p1Process(targetpiao,args(egon,))p2Process(targetpiao,args(alex,))p3Process(targetpiao,args(yuanhao,))p4Process(targetpiao,args(wupeiqi,))start_timetime.time()p1.start()p2.start()p3.start()p4.start()p1.join()p2.join()p3.join()p4.join()end_timetime.time()print(end_time-start_time) #结果为3.多print(主线程) #最后才被打印 egon is running
lishi is running
alex is running
jassin is running
egon is run end
lishi is run end
alex is run end
jassin is run end
3.2911880016326904
zhu 解释p.join()是让主线程等待p的结束卡住的是主线程而绝非进程p进程只要start就会在开始运行了,所以p1-p4.start()时,系统中已经有四个并发的进程了而我们p1.join()是在等p1结束,没错p1只要不结束主线程就会一直卡在原地,这也是问题的关键join是让主线程等,而p1-p4仍然是并发执行的,p1.join的时候,其余p2,p3,p4仍然在运行,等p1.join结束,可能p2,p3,p4早已经结束了,这样p2.join,p3.join.p4.join直接通过检测无需等待所以4个join花费的总时间仍然是耗费时间最长的那个进程运行的时间。 串行效果 from multiprocessing import Process
import time
def run(name):print(%s is running %name)time.sleep(3)print(%s is run end%name)
if __name__ __main__:p1 Process(targetrun,args(egon,))p2 Process(targetrun,args(alex,))p3 Process(targetrun,args(lishi,))p4 Process(targetrun,args(jassin,))start_time time.time()p1.start()p1.join()p2.start()p2.join()p3.start()p3.join()p4.start()p4.join()end_time time.time()print(end_time - start_time)print(zhu) 结果
egon is running
egon is run end
alex is running
alex is run end
lishi is running
lishi is run end
jassin is running
jassin is run end
12.697726249694824
zhu 解释以上p1,p2,p3,p4进程是上一个子进程执行完才逐一被启动形成串行效果。 六、进程池(Pool) 多进程是实现并发的主要手段之一但是通常会有如下问题a.很明显需要并发执行的任务通常要远大于核数;b.一个操作系统不可能无限开启进程通常有几个核就开几个进程;c.进程开启过多效率反而会下降开启进程是需要占用系统资源的而且开启多余核数目的进程也无法做到并行。 Pool可以提供指定数量的进程供用户调用当有新的请求提交到pool中时如果池还没有满那么就会创建一个新的进程用来执行该请求但如果池中的进程数已经达到规定最大值那么该请求就会等待直到池中有进程结束就重用进程池中的进程。执行任务的进程数始终位进程池中指定的那几个。 1、同步调用 同步调用提交完任务后在原地等待任务结束,一旦结束可以立刻拿到结果。 from concurrent.futures import ProcessPoolExecutor
import time,random,os
def run(name,n):print(%s is running %s %(name,os.getpid()))time.sleep(1)return n**2
if __name__ __main__:pProcessPoolExecutor(4)for i in range(10):resp.submit(run,alex %s %i,i).result() #同步调用#等进程执行完并能得到结果然后才开启下一个进程相当于串行 print(res)p.shutdown(waitTrue)print(主,os.getpid()) 2、异步调用 异步调用提交完任务后不会在原地等待任务结束,会继续提交下一次任务等到所有任务都结束后才能get结果。 from concurrent.futures import ProcessPoolExecutor
import time,os
import random
def work(n):print(%s is working %(os.getpid()))time.sleep(1)return n**2if __name____main__:pProcessPoolExecutor(4) #从无到有开启4个进程而且一直是这4个进程objs[]for i in range(10):objsp.submin(work,alex %s%i,i) #提交任务不会在原地等结果objs.append(obj)
异步apply_async用法如果使用异步提交的任务主进程需要使用jion等待进程池内任务都处理完然后可以用get收集结果否则主进程结束进程池可能还没来得及执行也就跟着一起结束了p.shutdown(wait True)print(主,os.geipid())for obj in objs:print(obj.result())提交/调用任务的方式有两种同步调用提交/调用一个任务然后就在原地等着等到该任务执行完毕拿到结果再执行下一行代码异步调用: 提交/调用一个任务不在原地等着直接执行下一行代码结果# from multiprocessing import Process,Pool
from concurrent.futures import ProcessPoolExecutor
import time,random,osdef piao(name,n):print(%s is piaoing %s %(name,os.getpid()))time.sleep(1)return n**2if __name__ __main__:pProcessPoolExecutor(4)objs[]
for i in range(10):# resp.submit(piao,alex %s %i,i).result() #同步调用# print(res)objp.submit(piao,alex %s %i,i) #异步调用objs.append(obj)for obj in objs:print(obj.result())# 关门等# pool.close()# pool.join()p.shutdown(waitTrue)print(主,os.getpid()) ****** from concurrent.futures import ProcessPoolExecutor
import time, random, osdef piao(name, n):print(%s is piaoing %s % (name, os.getpid()))time.sleep(1)return n ** 2if __name__ __main__:p ProcessPoolExecutor(4)objs []start time.time()for i in range(10):# resp.submit(piao,alex %s %i,i).result() #同步调用# print(res)obj p.submit(piao, alex %s % i, i) # 异步调用objs.append(obj)p.shutdown(waitTrue)print(主, os.getpid())for obj in objs:print(obj.result())stop time.time()print(stop - start) ** from concurrent.futures import ProcessPoolExecutor
import time,random,osdef piao(name):print(%s is piaoing %s %(name,os.getpid()))time.sleep(random.randint(1,4))if __name__ __main__:pProcessPoolExecutor(4)for i in range(10):p.submit(piao,alex %s %i)p.shutdown(waitTrue) # shutdown 关门 waitTrue 等print(主,os.getpid()) 转载于:https://www.cnblogs.com/jassin-du/p/7921296.html
