1 进程调度算法(了解)
-先来先服务调度算法
-短作业优先调度算法
-时间片轮转法
-多级反馈队列
2 同步异步,阻塞非阻塞(了解)
1 同步调用:提交了以后,一直等待结果返回
2 异步调用:提交了以后,返回一个标志,等执行完成后,有消息通知
3 同步,异步:指的是消息通知机制
4 阻塞,非阻塞:程序在等待调用结果的状态
5 同步阻塞:打电话要买书,如果电话没挂,我也一直在等待,
6 同步非阻塞:打电话买书,电话没挂,我一边干别的事,一边听一下电话
7 异步阻塞:打电话买书,电话先挂掉,过一会老板会回回来(回调),老板给回电话的过程一直在等待
8 异步非阻塞:打电话买书,电话先挂掉,过一会老板会回回来(回调),老板给回电话的过程中,在干别的事
3 Process类的参数(重点)
from multiprocessing import Process
def task(name,age):
print(name)
print(age)
if __name__ == '__main__':
# p=Process(target=task,args=['lqz',18])
# p=Process(target=task,kwargs={'age':19,'name':'lqz'},name='process01')
p=Process(target=task,kwargs={'age':19,'name':'lqz'})
p2=Process(target=task,kwargs={'age':19,'name':'lqz'})
p.start()
p2.start()
print(p.name)
print(p2.name)
# target=None, 你要执行的任务,函数
# name=None, 进程名
# args=(), 以位置参数给任务(函数)传递参数
# kwargs={} 以关键字的形式给任务(函数)传递参数
4 Process类的方法,属性(重点)
from multiprocessing import Process
import time
def task(name,age):
time.sleep(10)
print(name)
print(age)
if __name__ == '__main__':
p=Process(target=task,kwargs={'age':19,'name':'lqz'})
p.start() #启动进程,必须调用start
# p.run() # 实际进程在执行的时候,执行的是run方法,但是调用run不会开进程,后面我们另一种开启进程的方案使用到它
# p.join() # 等待子进程执行完成
print(p.is_alive()) #True
p.terminate() # 杀死p这个进程,通知操作系统去杀死该进程
time.sleep(0.1)
print(p.is_alive()) #可能还是True
print('ssss')
print(p.is_alive()) #就是False
print(p)
'''
p.start() #启动进程,必须调用start
p.run() # 实际进程在执行的时候,执行的是run方法,但是调用run不会开进程,后面我们另一种开启进程的方案使用到它
p.join() # 等待子进程执行完成
p.terminate() # 杀死p这个进程,通知操作系统去杀死该进程,并不是立即结束
p.is_alive() #进程是否还存活
'''
2.1 属性
from multiprocessing import Process
import time
def task(name,age):
time.sleep(10)
print(name)
print(age)
if __name__ == '__main__':
p=Process(target=task,kwargs={'age':19,'name':'lqz'})
# p.start()
# print(p.name) # 进程名字
# p.daemon=True #主进程结束,子进程也结束,必须在start之前调用
p.start()
print(p.pid) # 进程id号
time.sleep(10)
'''
print(p.name) # 进程名字
print(p.pid) # 进程id号
p.daemon=True #主进程结束,子进程也结束,必须在start之前调用
'''
主进程和子进程的进程号
from multiprocessing import Process
import time
import os
def task(name,age):
# 如果在任务中取出进程id号,需要使用os模块
print('当前进程(子进程)id号是:',os.getpid()) #当前进程id号
print('当前进程父进程的id号是:',os.getppid()) # 当前进程父进程的id号
time.sleep(10)
print(name)
print(age)
if __name__ == '__main__':
p=Process(target=task,kwargs={'age':19,'name':'lqz'})
p.start()
print('p这个进程的id号是:',p.pid) # 进程id号
print('当前进程id(主进程)号是:', os.getpid()) # 当前进程id号
print('当前进程父进程(pycharm)的id号是:', os.getppid()) # 当前进程父进程的id号
time.sleep(10)
'''
如果有p对象,就是用p.pid获取进程id号
如果没有p对象,就是用os模块的
os.getpid() #当前进程id号
os.getppid() #父进程id号
'''
同时开启多个进程
from multiprocessing import Process
import time
import os
# def task(name,age):
# time.sleep(10)
# print(name)
# print(age)
# def task1():
# time.sleep(2)
# print("我是task1")
#
#
# if __name__ == '__main__':
# p=Process(target=task,kwargs={'age':19,'name':'lqz'})
# p.start()
#
# p1=Process(target=task1)
# p1.start()
#
# print('主进程')
import time
def task1(i):
time.sleep(2)
print("我是task1",i)
if __name__ == '__main__':
ctime=time.time()
ll=[]
for i in range(5):
p1=Process(target=task1,args=[i,])
p1.start()
p1.join() #等待子进程执行完成
# ll.append(p1)
# for p in ll:
# p.join()
[p.join()for p in ll]
print('主进程')
print(time.time()-ctime)
'''
开启多个进程
如果想等待多个进程同时执行完,先把进程开启完成,再统一join
'''
开启进程的另一种方案
### 通过继承Process类的方式来实现,重写run方法,run方法就是你要执行的任务,实例化得到对象,调用start方法开启进程
class MyProcess(Process):
def __init__(self,name1,age):
self.name1=name1
self.age=age
# 这个必须写
super().__init__()
def run(self) :
time.sleep(2)
print(self.name)
print(self.name1)
print(self.age)
if __name__ == '__main__':
p=MyProcess('lqz',19)
p.start() #调用p.start(),不要调用run
print('主进程')
进程之间数据隔离
from multiprocessing import Process
import time
import os
def task():
print('我是task')
global n
n=100
print('子进程的:',n)
if __name__ == '__main__':
# 在主进程中定义了一个n=10
n=10
###如果这样写,n会被改掉
# task()
# print(n)
##如果这样写,n不会被改掉
p=Process(target=task)
p.start()
print('主进程的:',n)
5 高并发的tcp服务端
import socket
from multiprocessing import Process
def talk(sock,addr):
print('客户端连接成功',addr)
while True:
try:
data = sock.recv(1024)
if len(data) == 0:
break
print('从客户端收到了:', data)
sock.send(data.upper())
except Exception as e:
print(e)
break
sock.close()
if __name__ == '__main__':
server = socket.socket()
server.bind(('127.0.0.1', 81))
server.listen(5)
while True:
print('等待客户端连接')
sock, addr = server.accept()
p=Process(target=talk,args=[sock,addr])
p.start()
server.close()
from multiprocessing import Process
import time
import os
def task():
print('我是task')
global n
n=100
print('子进程的:',n)
if __name__ == '__main__':
# 在主进程中定义了一个n=10
n=10
###如果这样写,n会被改掉
# task()
# print(n)
##如果这样写,n不会被改掉
p=Process(target=task)
p.start()
print('主进程的:',n)
5 进程同步(进程锁)(次重点)
import time
## 不加锁
import json
from multiprocessing import Process,Lock
## 查询票余额
def check(i):
with open('ticket', 'rt', encoding='utf-8') as f:
res = json.load(f)
print('%s:在查询票,票还剩%s张' % (i, res['count']))
if res['count'] > 0:
return True
## 抢票,票的余额减一
def buy(i):
with open('ticket', 'rt', encoding='utf-8') as f:
res = json.load(f)
time.sleep(1) # 模拟查票延迟
if res['count'] > 0:
print('%s现在要买了,票数还是大于0'%i)
res['count'] -= 1
time.sleep(2) # 模拟买票延迟
with open('ticket', 'wt', encoding='utf-8') as f1:
json.dump(res, f1)
print('%s这个人购票成功' % i)
else:
print('%s这个人购票失败,票不够了,买不了了' % i)
def task(i,lock):
res = check(i)
if res:
lock.acquire()
buy(i)
lock.release()
##模拟10个人买票
if __name__ == '__main__':
lock=Lock()
for i in range(10):
p = Process(target=task, args=[i,lock ])
p.start()