python 进阶 进程

【进程】： 是操作系统 分配的 调度的 基本单位， 运行中的程序 就是一个进程
【串行】： 一段时间内 只能完成一件事 ，早期单核cpu
【并行】： 一段时间内 完成多件事， cpu的核心个数
【并发】： 很短的一段时间内 只能完成一件事，模拟单核cpu处理多任务
【同步】： 一个任务执行时，另外一个任务等待执行结束
【异步】： 两个任务并发执行

window端 不支持 fork() 创建多进程

递归： 递归深度值？？？？ 【操作系统 分配 内存】！！

使用 multiprocessing 创建 进程

from multiprocessing import Process # 导入进程模块
import os,time
def task(): # 进程的任务！
for i in range(10):
print(os.getpid(),i)
time.sleep(1)
if name == ‘main’:
x=Process(target=task) # 创建进程对象！！
x.start() # 开启进程 子进程
time.sleep(2)
# x.terminate() # 结束进程
# x.join() # 让 其他进程等待， 当前执行完 ，在执行 其他进程 #ex.shutdown(wait=True)是进程池内部的进程都执行完毕，才会关闭，然后执行后续代码
# for i in range(10):
# print(‘该进程是谁？主进程’, os.getpid())
# time.sleep(1)
print(‘end’)

进程之间的变量

在main函数里传方法的参数，用ages传参
【每个进程拥有独立 的 资源】 非共享！！！
【每个进程拥有独立 的 资源】 非共享！！！

守护（后台）进程：daemon 属性值（bool值）：
True ： 主进程结束 子进程 直接结束
False: 默认值，主进程结束 子进程继续执行

休眠放在main方法里面都是控制的父进程

【进程池】

from multiprocessing import Pool,process
【 有这样一个任务！！ 搬砖】
总任务量 100
进程
def task():
print(process.current_process().name,os.getpid(),“搬砖+1”)
time.sleep(1)
if name == ‘main’:
p=Pool() # 【1.创建进程池】–>进程池中有n个进程
for i in range(100): # 【2.分配任务】
# p.apply(task) #同步
p.apply_async(task) #异步
p.close() # 【3.关闭进程池】
p.join() # 【4.等待进程池 执行完 】
print(“end”)
【 进程池 任务 传参】
def task(num):
for i in range(num):
print(process.current_process().name,os.getpid(),“搬砖”,i)
time.sleep(1)
if name == ‘main’:
p=Pool(2) # 【1.创建进程池】–>进程池中有n个进程
for i in range(5): # 【2.分配任务】
# p.apply(task) #同步
p.apply_async(task,args=(5,)) #异步 写入变量
p.close() # 【3.关闭进程池】
p.join() # 【4.等待进程池 执行完 】
print(“end”)

~~阻塞队列~

from multiprocessing import Queue
x=Queue(5)
x.put(‘q’)
x.put(‘w’)
x.put(‘e’)
x.put(‘r’)
x.put(‘t’)

x.put(‘y’,block=True,timeout=3) # 在等待 队列多余位置，进队列
x.get(block=True,timeout=3) # 在等待 队列元素，出队列

x.put_nowait() # 等价于–>put(block=False)
x.get_nowait() # 等价于–> get(block=False)

print(x.qsize()) # 当前元素个数
print(x.full()) #是否满
print(x.empty()) # 是否空

使用阻塞队列简单实现进程之间的通信

import time,os,random
from multiprocessing import Process,Queue
def read(q):
while True:
try:
print(os.getpid(),“读取数据为？”,q.get(timeout=3)) # 空了就阻塞，有数据就出队列
except:
print(“读取数据超时~~”,os.getpid())
break
time.sleep(random.random())

def write(q,num):
for i in range(num):
q.put(i) # 满了就阻塞等待， 不满 入队列数据
print(“写入数据》”,i)
time.sleep(random.random())

if name == ‘main’:
q=Queue(5) # 被 四个进程 访问的

t1 = Process(target=write,args=(q,10))
t4 = Process(target=write, args=(q, 20))

t2 = Process(target=read,**args=(q,)**)   要是元组
t3 = Process(target=read, args=(q,))

t1.start()
t2.start()
t3.start()
t4.start()

t1.join()
t2.join()
t3.join()
t4.join()

print("end")

进程锁不能够加在方法首部，应该加载某个循环或者某个容易冲突，需要加锁的地方

Lock.acquire 加锁 Lock.release 释放锁

守护进程 Daemon

主进程创建守护进程
　　其一：守护进程会在主进程代码执行结束后就终止
　　其二：守护进程内无法再开启子进程,否则抛出异常：
注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止