进程调度
要想多个进程交替运行,操作系统必须对这些进程进行调度,这个调度也不是随即进行的,而是要遵循一定的法则,由此仅有了进程的调度算法
先来先服务调度算法
短作业优先调度算法
时间片转轮法
多级反馈队列
僵尸进程与孤儿进程
僵尸进程:进程结束了,资源还没来得及回收
孤儿进程:主进程挂了,子进程还没结束,她就会被专门的进程接管
守护进程
会随着主进程的结束而结束.
主进程创建守护进程
1,守护进程会在主进程代码执行结束后就终止
2,守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic processes are not allowed to have children
进程之间是互相独立的,主进程代码运行结束,守护进程随即终止
from multiprocessing import Process, current_process
import time, os
def task():
print(os.getpid())
print('子进程')
time.sleep(100)
print('子进程结束')
if __name__ == '__main__':
t = Process(target=task, )
# 守护进程:主进程一旦结束,子进程也结束
# t.daemon=True # 一定要加在启动之前
t.start()
time.sleep(1)
print('主进程结束')
进程互斥锁
进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争.竞争带来的的结果就是错乱,如何控制就是加锁处理
# 同时只有一个人能拿到,必须释放,其他人才能再次获取到
from multiprocessing import Process, Lock
import json, time, random
def check_tickets():
# 查票函数,打开文件,读出tickets_count
with open('tickets', 'r', encoding='utf-8')as f:
dic = json.load(f)
print('余票还有:', dic.get('tickets_count'))
def buy_tickets():
with open('tickets', 'r', encoding='utf-8')as f:
dic = json.load(f)
# 模拟网络延时
time.sleep(random.randint(1, 3))
if dic.get('tickets_count') > 0:
dic['tickets_count'] -= 1
with open('tickets', 'w', encoding='utf-8')as f:
json.dump(dic, f)
print('买票成功')
else:
print('买票失败')
# 写一个函数,先查票,在买票
def task(mutex):
check_tickets()
# 买票过程加锁
# 买前加锁
# mutex.acquire()
# buy_tickets() # 10个进程变成了串行执行
# 买后释放锁
# mutex.release()
with mutex:
buy_tickets()
if __name__ == '__main__':
# 锁的创建,主进程创建锁
mutex = Lock() # 创建一把锁
# 模拟10个人买票(开10个进程)
for i in range(10):
t = Process(target=task, args=(mutex,))
t.start()
总结:加锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,没错,速度是慢了,但牺牲了速度却保证了数据安全
问题
1,效率低(共享数据基于文件,而文件是硬盘上的数据)
2,需要自己加锁处理
队列介绍
创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间额数据传递.
队列支持多个人从队列的一端放入数据,同样支持多个从队列的宁一端取数据
Queue([maxsize])
创建共享的进程队列.
参数:maxsize是队列中允许的最大项数.如果省略此参数,则无大小限制
底层队列使用管道和锁定实现
Queue([maxsize])
创建共享的进程队列。maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。底层队列使用管道和锁定实现。另外，还需要运行支持线程以便队列中的数据传输到底层管道中。
Queue的实例q具有以下方法：
q.get( [ block [ ,timeout ] ] )
返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。block用于控制阻塞行为，默认为True. 如果设置为False，将引发Queue.Empty异常（定义在Queue模块中）。timeout是可选超时时间，用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。
q.get_nowait( )
同q.get(False)方法。
q.put(item [, block [,timeout ] ] )
将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。block控制阻塞行为，默认为True。如果设置为False，将引发Queue.Empty异常（定义在Queue库模块中）。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。
q.qsize()
返回队列中目前项目的正确数量。此函数的结果并不可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。在某些系统上，此方法可能引发NotImplementedError异常。
q.empty()
如果调用此方法时 q为空，返回True。如果其他进程或线程正在往队列中添加项目，结果是不可靠的。也就是说，在返回和使用结果之间，队列中可能已经加入新的项目。
q.full()
如果q已满，返回为True. 由于线程的存在，结果也可能是不可靠的（参考q.empty（）方法）。。
q.close()
关闭队列，防止队列中加入更多数据。调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。例如，如果某个使用者正被阻塞在get（）操作上，关闭生产者中的队列不会导致get（）方法返回错误。
q.cancel_join_thread()
不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。
q.join_thread()
连接队列的后台线程。此方法用于在调用q.close()方法后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。
from multiprocessing import Queue
# 实例化得到要给对象
q=Queue(5) # 默认很大,可以放很多,谢了5个,只能放5个
# 往管道中放值
q.put(1)
q.put('lqz')
q.put(18)
q.put(19)
# q.put(20)
# q.put(21)
# q.put_nowait(100)
# 从管道中取值
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get(timeout=100)) # 等0.1s还没有值，就结束
# print(q.get_nowait()) # 不等了，有就是有，没有就没有
print(q.empty()) # 看一下队列是不是空的
print(q.full()) # 看一下队列是不是满的
# 总结：
'''
q=Queue(队列大小)
# 放值
q.put(asdf)
q.put_nowait(asdf) # 队列满了，放不进去就不放了，报错
# 取值
q.get() # 从队列头部取出一个值
q.get_nowait() # 从队列头部取值，没有就抛错
# 队列是否为空，是否满
print(q.empty()) # 看一下队列是不是空的
print(q.full()) # 看一下队列是不是满的
IPC机制(进程间通信)
# Inter-Process Communication，进程间通信
from multiprocessing import Process, current_process, Queue
import time, os
def task1(q):
print('我是task1进程,我的id号是:%s' % os.getpid())
q.put('lqz is dsb')
def task2(q):
print('我是task2进程,我的id号是:%s' % os.getpid())
if __name__ == '__main__':
q = Queue
t1 = Process(target=task1,args=(q,))
t1.start()
t2 = Process(target=task2,args=(q,))
t2.start()
print(q.get())