章节
- 创建进程的多种方式
- join方法
- 进程间数据默认隔离
- 进程间通信（IPC机制）
- 生产者和消费者模型
- 进程相关方法
- 守护进程
- 僵尸进程与孤儿进程
- 互斥锁
创建进程的多种方式
-
1.鼠标点击双击运行
-
2.代码创建
from multiprocessing import Process
import time
# def task(name):
# print(f'{name}正在运行')
# time.sleep(3)
# print(f'{name}运行结束')
#
#
# if __name__ == '__main__':
# p = Process(target=task, args=('jason',)) # 创建一个进程对象
# p.start() # 告诉操作系统创建一个进程(异步操作)
# # task('jason') # 普通的函数调用是同步操作
# print('主进程')
-----------------------------------------------------------------------------------
"""
创建进程的代码在不同的操作系统中 底层原理有区别!!!
在windows中 创建进程类似于导入模块
if __name__ == '__main__': 启动脚本
在mac、linux中 创建进程类似于直接拷贝
不需要启动脚本 但是为了兼容性 也可以使用
"""
class MyProcess(Process):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print(f'{self.name}正在运行')
time.sleep(5)
print(f'{self.name}运行结束')
if __name__ == '__main__':
obj = MyProcess('jason')
obj.start()
print('主进程')
join方法
作用：
join:主进程等待子进程运行结束之后再运行
join实战：
-----------------------------------------------------
推导步骤2:join方法【合理方式】 很合理！！！
-----------------------------------------------------
from multiprocessing import Process
import time
def task(name,n):
print(f'{name}正在运行')
time.sleep(n)
print(f'{name}运行结束')
if __name__ == '__main__':
p1 = Process(target=task, args=('jason', 1)) # args就是通过元组的形式给函数传参
p2 = Process(target=task, args=('kevin', 2)) # 也可以通过kwargs={'name':'jason', 'n':1} 太麻烦 没必要
p3 = Process(target=task, args=('jerry', 3))
start_time = time.time()
p1.start()
p2.start()
p3.start()
p1.join()
p2.join()
p3.join()
end_time = time.time() - start_time
print('总耗时：%s' % end_time)
print('主进程')
------------执行结果----------------
jason正在运行
kevin正在运行
jerry正在运行
jason运行结束
kevin运行结束
jerry运行结束
总耗时：3.1067492961883545
主进程
-
join注意事项
一定要看准join的执行位置 以及多任务情况下等待的目标
进程特点：进程间数据默认隔离
多个进程数彼此之间默认是相互隔离的
如果真的想交互，需要借助于'管道'或者'队列'
from multiprocessing import Process
money = 100
def task():
global money
money = 666
print('子进程打印的money', money)
if __name__ == '__main__':
p = Process(target=task)
p.start()
p.join()
print('父进程打印的money', money)
------执行结果---------------
子进程打印的money 666
父进程打印的money 100
进程间通信（IPC机制）
Queue模块
队列，是一个先进先出的容器
| 方法 |
作用 |
| .get() |
获取队列内容 |
| .put() |
往队列中添加 |
| .full() |
判断队列是否已存满 |
| .get_nowait() |
取出队列数据，无数据取出直接报错 |
| .empty() |
判断队列是否已空 |
Queue实战
q.full()
q.empty()
q.get_nowait()
上述方法在多进程下不能准确使用(失效)!!!
预备知识
什么是队列:先进先出
-------------------------例子----------------------------------
# 1.创建队列对象
from multiprocessing import Queue
q =Queue(3) #指定只允许存储3条 #括号内指定队列可以容纳的数据个数 默认:2147483647
q.put(111)
print(q.full()) #判断是存满
----执行结果-------
False
print(q.get())
----执行结果-------
111
---------如果存入队列4个----------------
q.put(111)
q.put(222)
q.put(333)
q.put(444) # 超出数据存放极限 那么程序一致处于阻塞态 直到队列中有数据被取出
----------如果连取4个---------------------
print(q.get()) # 超出数据获取极限 那么程序一致处于阻塞态 直到队列中有数据被添加
print(q.get())
print(q.get())
print(q.get())
------------暴躁取值---------------
print(q.get_nowait())
print(q.get_nowait())
print(q.get_nowait())
print(q.get_nowait()) # 队列中如果没有数据可取 直接报错
========================================================================
IPC机制
1.主进程与子进程通信
2.子进程与子进程通信
from multiprocessing import Queue, Process
def procedure(q):
q.put('子进程procedure往队里中添加了数据')
def consumer(q):
print('子进程的consumer从队列中获取数据', q.get())
if __name__ == '__main__':
q = Queue() # 在主进程中产生q对象 确保所有的子进程使用的是相同的q
p1 = Process(target=procedure, args=(q,))
p2 = Process(target=consumer, args=(q,))
p1.start()
p2.start()
print('主进程')
------------执行结果-----------------
主进程
子进程的consumer从队列中获取数据 子进程procedure往队里中添加了数据
生产消费者模型
| 模型 |
作用 |
| 生产者 |
产生数据 |
| 消息队列 |
数据库/rabitmq/redis/zk/kafka |
| 消费者 |
处理数据 |
进程相关方法
| 方法 |
作用 |
| .pid |
查看pid进程号 |
| os.getpid |
查看pid进程号 |
| os.getppid |
查看父进程号 |
| .terminate() |
销毁子进程 |
| .is_alive() |
判断进程是否存活 |
守护进程
如何理解守护
伴随着守护对象的存活而存活 死亡而死亡
-------------------例子-----------------------------------------------
from multiprocessing import Process
import time
def task(name):
print('大内总管:%s存活' % name)
time.sleep(3)
print('大内总管:%s嗝屁' % name)
if __name__ == '__main__':
p = Process(target=task, args=('基佬',))
p.daemon = True # 必须在start之前执行
p.start() # 将子进程设置为守护进程:主进程代码结束 子进程立刻结束
print('天子Jason寿终正寝!!!')
僵尸进程与孤儿进程
| 进程 |
| 僵尸进程 |
| 进程已经运行结束，但是相关的自愿并没有完全清空，需要父进程参与回收 |
| 孤儿进程 |
| 操作系统领域中，父进程意外终止结束，子进程正常运行，该子进程就称之为孤儿进程，这些孤儿进程，被init进程收养，由init进程对他们完成状态收集工作 |
互斥锁
--------例子---------------
from multiprocessing import Process
import time
import json
import random
# 查票
def search(name):
with open(r'data.json', 'r', encoding='utf8') as f:
data = json.load(f)
print('%s在查票 当前余票为:%s' % (name, data.get('ticket_num')))
# 买票
def buy(name):
# 再次确认票
with open(r'data.json', 'r', encoding='utf8') as f:
data = json.load(f)
# 模拟网络延迟
time.sleep(random.randint(1, 3))
# 判断是否有票 有就买
if data.get('ticket_num') > 0:
data['ticket_num'] -= 1
with open(r'data.json', 'w', encoding='utf8') as f:
json.dump(data, f)
print('%s买票成功' % name)
else:
print('%s很倒霉 没有抢到票' % name)
def run(name):
search(name)
buy(name)
if __name__ == '__main__':
for i in range(10):
p = Process(target=run, args=('用户%s'%i, ))
p.start()
