1、进程概念
进程是一个执行中的程序，资源分配的最小单位。每个进程都拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据。在单核CPU系统中的多进程，内存中可以有许多程序，但在给定一个时刻只有一个程序在运行；就是说，可能这一秒在运行进程A，下一秒在运行进程B，虽然两者都在内存中，都没有真正同时运行。
2、获取进程号方法
""" ps -aux 查看进程号 ps -aux | grep 2860 kill -9 2860 杀死进程 """ # 获取当前进程id (子进程) res = os.getpid() print(res) # 获取当前进程的父进程 res2 = os.getppid() print(res2)
3、进程基本使用
from multiprocessing import Process #1、创建基本进程 def func(): print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid())) # 为了解决windows 和 linux 系统的兼容问题,下面这句话必须加上,否则报错 if __name__ == "__main__": # 创建子进程,返回进程对象,执行func这个任务 p = Process(target=func) # 调用子进程 p.start() #2、创建带有参数的进程 def func(n): for i in range(1,n+1): print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid())) if __name__ == "__main__": n = 5 #创建子进程 p = Process(target=func,args=(n,)) #调用子进程 p.start() for i in range(1,n+1): print("*" * i) #3、进程间的数据彼此隔离 count = 10 def func(): global count count += 1 print("我是子进程count={}".format(count)) if __name__ == "__main__": p=Process(target=func) p.start() time.sleep(1) print(count)
4、相关信息
多个进程之间是异步并发的程序,因为cpu的调度策略问题,不一定哪个任务先执行,哪个任务后执行.
整体而言,主进程比子进程创建的速度要快,cpu遇到阻塞会立刻切换任务,等到阻塞态的任务变成了就绪态,cpu再回来执行
主程序会默认等到所有的子程序执行结束之后,在统一关闭程序,释放资源.
若不等待,有可能在后台存有多个未执行结束的子进程,会变成僵尸进程,不停的占用cpu,内存
增加系统的压力,所有方便于对进程的管理,主进程默认等待子进程.
5、join等待当前子进程全部执行完毕之后,主进程在执行(用来同步子父进程的)
from multiprocessing import Process import time,os # (1) join 基本语法 def func(): print("发送第一封邮箱,要求张工资") if __name__ == "__main__": p = Process(target=func) p.start() # 必须等待子进程全部执行结束之后,在执行主进程中的代码,用join来同步子父进程. p.join() # time.sleep(1) print("发送第二封邮箱,涨到一个月6万") # (2) 多个子进程的场景中使用join def func(i): time.sleep(1) print("发送第%s封邮箱,要求升职加薪" % (i)) if __name__ == "__main__": lst = [] for i in range(10): p = Process(target=func,args=(i,)) p.start() lst.append(p) for i in lst: i.join() print("主进程发最后一封邮件:此致敬礼~")
6、使用自定义方法创建进程（必须继承Process这个父类，所有进程执行任务的逻辑必须写在run方法里面）
# 1.基本语法 class MyProcess(Process): def run(self): print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid())) if __name__ == "__main__": p = MyProcess() p.start() print("3.子进程id>>{},4父进程id>>{}".format(os.getpid(),os.getppid())) # 2.带有参数自定类的方法 class MyProcess(Process): def __init__(self,arg): # 手动调用一下父类的构造方法(最终实现进程的创建) super().__init__() self.arg = arg def run(self): print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid())) print(self.arg) if __name__ == "__main__": p = MyProcess("我是传进来的参数") p.start() print("3.子进程id>>{},4父进程id>>{}".format(os.getpid(),os.getppid()))
7、守护进程
守护进程守护的是主进程,如果主进程中的所有代码执行完毕了,
当前这个守护进程会被立刻杀死,立刻终止.
语法:
进程.daemon = True 设置当前这个进程为守护进程
必须写在start()调用进程之前进行设置
默认:主进程会默认等待所有子进程执行结束之后,在关闭程序,释放资源
from multiprocessing import Process import time # (1) 基本使用 def func(): print("start当前子进程") time.sleep(1) print("end当前子进程") if __name__ == "__main__": p = Process(target = func) p.daemon = True p.start() print("主进程执行结束 ... ") # (2) 多个子进程的场景 def func1(): count = 1 while True: print("*" * count) time.sleep(0.5) count += 1 def func2(): print("start func2 当前子进程任务") time.sleep(3) print("end func2 当前子进程任务") if __name__ == "__main__": p1 = Process(target=func1) p2 = Process(target=func2) # 设置p1这个进程对象为守护进程 p1.daemon = True p1.start() p2.start() time.sleep(1) print("主进程执行结束 ... ")
8、锁
上锁和解锁是一对,只上锁不解锁会发生死锁现象(代码阻塞,不往下执行了)
互斥锁 : 互斥锁是进程之间的互相排斥,谁先抢到这个锁资源就先使用,后抢到后使用
from multiprocessing import Process,Lock # 创建一把锁 lock = Lock() # 上锁 lock.acquire() # 连续上锁不解锁是死锁 # lock.acquire() error print("运行中...") # 解锁 lock.release() print("执行程序 ... ")
9、信号量
信号量 Semaphore 本质上就是锁,只不过可以控制上锁的数量
Semaphore 可以设置上锁的数量
同一时间最多允许几个进程上锁
创建进程的时候,是异步并发
执行任务的时候,遇到锁会变成同步程序
from multiprocessing import Semaphore,Process import time,random sem = Semaphore(4) sem.acquire() # sem.acquire() # sem.acquire() # sem.acquire() # sem.acquire() # 上第五把锁出现死锁状态. print("执行响应的操作") sem.release() def ktv(person,sem): sem.acquire() print("%s进入了ktv,正在唱歌" % (person)) # 开始唱歌,唱一段时间 time.sleep(random.randrange(3,7)) # 3 4 5 6 print("%s离开了ktv,唱完了" % (person)) sem.release() if __name__ == "__main__": sem = Semaphore(4) lst = ["ss","bb","dd"] for i in lst: p = Process(target=ktv,args=(i,sem)) p.start()
10、事件(Event)
阻塞事件 ：
e = Event()生成事件对象e
e.wait()动态给程序加阻塞 , 程序当中是否加阻塞完全取决于该对象中的is_set() [默认返回值是False]
如果是True 不加阻塞
如果是False 加阻塞
控制这个属性的值
set()方法 将这个属性的值改成True
clear()方法 将这个属性的值改成False
is_set()方法 判断当前的属性是否为True (默认上来是False)
from multiprocessing import Process,Event import time,random # 1基本使用 e = Event() print(e.is_set()) e.wait() print("程序运行中 ... ") #2 e = Event() e.set() # 将内部成员属性值由False -> True print(e.is_set()) e.wait() print("程序运行中 ... ") e.clear() # 将内部成员属性值由True => False e.wait() print("程序运行中2 ... ") #3 e = Event() # wait参数 可以写时间 wait(3) 代表最多等待3秒钟 e.wait(3) print("程序运行中3 ... ")
11、进程队列（可实现数据共享）
from multiprocessing import Process,Queue import queue """队列特点: 先进先出,后进后出""" q = Queue() # 1.put 往队列中放值 q.put(100) q.put(101) q.put(102) # 2.get 从队列中取值 res = q.get() print(res) res = q.get() print(res) # res = q.get() # print(res) # 3.队列中如果已经没有数据了,在调用get会发生阻塞. res = q.get() print(res) # 4.get_nowait 存在系统兼容性问题[windows]好用 [linux]不好用 不推荐 res = q.get_nowait() print(res) try: res = q.get_nowait() print(res) except queue.Empty: pass # 5.设置队列的长度 """设置队列长度最多存放4个元素""" print("<======>") q2 = Queue(4) q2.put(200) q2.put(201) q2.put(202) # q2.put(203) # 如果超过了队列的指定长度,在继续存值会出现阻塞现象 # q2.put(204) # 6.put_nowait() 非阻塞版本的put,超出长度后,直接报错 q2.put_nowait(204) try: q2.put_nowait(205) except queue.Full: pass # ### 2.进程之间的数据共享 def func(q3): # 2.子进程获取数据 res = q3.get() print(res) # 3.子进程存数据 q3.put("马生平") if __name__ == "__main__": q3 = Queue() p = Process(target=func,args=(q3,)) p.start() # 1.主进程添加数据 q3.put("王凡") # 为了等待子进程把数据放到队列中,需要加join p.join() # 4.主进程获取数据 res = q3.get() print(res) print("主程序结束 ... ")
12、JoinableQueue
from multiprocessing import Process, JoinableQueue import time,random """ put 存储 get 获取 task_done join task_done 和 join 配合使用的 队列中 1 2 3 4 5 put 一次 内部的队列计数器加1 get 一次 通过task_done让队列计数器减1 join函数,会根据队列计数器来判断是阻塞还是放行 队列计数器 = 0 , 意味着放行 队列计数器 != 0 , 意味着阻塞 """ # 基本语法 """ jq =JoinableQueue() jq.put("a") print(jq.get()) # 通过task_done让队列计数器减1 jq.task_done() jq.join() print("finish") """
13、 Manager ( list 列表 , dict 字典) 进程之间的共享数据(列表或者字典等)
rom multiprocessing import Process,Manager,Lock def work(data,lock): # 1.正常写法 """ # 上锁 lock.acquire() # 修改数据 data["count"] -= 1 # 解锁 lock.release() """ # 2.使用with语法可以简化上锁和解锁两步操作 with lock: data[0] += 1 if __name__ == "__main__": lst = [] lock = Lock() m = Manager() data = m.dict( {"count":20000} ) data = m.list( [1,2,3] ) for i in range(50): p = Process(target=work,args=(data,lock)) p.start() lst.append(p) # 确保所有进程执行完毕之后,在向下执行,打印数据,否则报错. for i in lst: i.join() print(data)
14、实现进程间通讯多种方式
管道，消息队列，共享内存
一、python中进程间通过管道的方式进行通信。创建一个管道，在进程的一端发送消息，在进程的另一端接收消息，通过这个内置的方法实现通信。一端发出消息，另一端接收消息。写法也比较简单，在上一篇文章中有对应示例。这里不再多做示例。
二、消息队列。创建一个中间容器，一端向中间容器中写入数据，另一端则去获取容器中数据，通过设置中间容器的方式实现通信。在这里我没有说明队列，而是用容器，而是因为其他容器也可以替代队列，只是队列在这里有一个极大的优势，就是队列中的数据有且只能取用一次，用完就没有了，所以不会出现重复。在这里就变的有优势。其实如果只是为了通信，也为了常规使用方便，或者控制更加精细，可以选择自己熟悉的容器都是可以的。如列表、元组、字典等其实都是可以的。就只是一端把数据放到中间容器中，另一商从中间容器中去获取即可。（在这里也不做演示，原理理解了，实现就只是技术上一的个小问题而已）。
三、共享内存。创建一个内存空间，然后向共享内存中写入数据，一端写入一端读取，通过这样的方式来实现内存共享。
原文地址：http://www.cnblogs.com/songyunjie/p/16829465.html
