回顾
1.操作系统发展史
- 穿孔卡片
- 联机批处理
- 脱机批处理
多道技术:
单道: 多个程序一串串执行
多道:
切换 + 保存状态1)空间上的复用
一个计算机(CPU)的空间可以提供给多个程序使用.2)时间上的复用
- 当前程序遇到IO操作,就会立马切换CPU的执行权限- 当前程序使用CPU时间过长,,就会立马切换CPU的执行权限
并发与并行
并发: 看起来像同时运行.
并行: 真实意义上的同时运行.在单核的情况下不能实现并行,要想实现并行,必须有多个CPU.
2.进程
程序: 一堆代码.
进程: 一堆代码运行的过程.
进程调度:
时间片轮转法 + 分级反馈队列- 进程的三种状态:
就绪态
所有进程在创建时都会先进入就绪态运行态
通过进程调度将每一个进程调入运行态扫描二维码关注公众号,回复: 7544228 查看本文章阻塞态
在运行态中的程序遇到IO就会进入阻塞态.
若IO结束,会立马进入就绪态,不会直接进入运行态.
注意: CPU的执行时间过长会看起来像阻塞,其实并不是阻塞,剥夺其CPU执行权限,然后会将该进程重新返回就绪态.
同步和异步
同步: 一个任务提交后,在原地等待该任务结束后,下一个才能提交并且执行.
异步: 一个任务提交后,不需要原地等待,立马可以执行下一个任务.- 阻塞与非阻塞
- 阻塞:
- 阻塞态
遇到IO,会进入阻塞态
- 阻塞态
- 非阻塞:
- 就绪态
- 运行态.
- 阻塞:
创建进程的两种方式:
from multiprocessing import Process
import time#方式一:
#在windows系统下创建,必须要在__main__执行
def task():
print('子进程开始执行')
time.sleep(1)
print('子进程结束完毕')__mian__下:
#target=执行任务(函数地址)
p = Process(target=task)
p.start() # 告诉操作系统,创建子进程#join
p.join() # 让主进程等待所有子进程结束后才能结束
print('主进程' )
#方式二:
自定义类,继承Process
class MyProcess(Process):def run(self):
# 此处是子进程的任务
print('子进程开始执行')
time.sleep(1)
print('子进程结束完毕')__mian__下:
p = MyProcess()
p.start() # 告诉操作系统,创建子进程
#join
p.join() # 让主进程等待所有子进程结束后才能结束
print('主进程' )
join() # 让主进程等待所有子进程结束后才能结束
进程间数据是隔离的
进程对象的属性
#可以获取子进程pid号
current_process().pid ---> return Process().pid
#在子进程中打印是子进程的pid号,在父进程中打印父进程的pid号
os.getpid()
#主主进程pid号
os.getppid()current_process() ---> p
#终止子进程
p.terminate()#判断进程是否存活
is_alive守护进程:
主进程结束后,子进程也要跟着结束#注意(******): 必须要在start()之前设置
p.daemon = True
p.start()
- 阻塞与非阻塞
p.daemon = True 报错
父进程回收子进程PID号的两种方式:
- join
父进程正常结束后
- 僵尸进程与孤儿进程(了解知识点):
- 僵尸进程: 子进程结束后,父进程没有回收PID,导致子进程永久保留PID号.
缺点: 占用PID号, 占用操作系统资源.
- 僵尸进程: 子进程结束后,父进程没有回收PID,导致子进程永久保留PID号.
孤儿进程:子进程还未结束,父进程意外结束,导致子进程在结束后父进程无法回收.
此使子进程就像一个"孤儿",然后由操作系统自带的"福利院"来回收.
进程互斥锁
让并发变成串行, 牺牲了执行效率, 保证了数据安全.
在程序并发执行时,需要修改数据时使用.
'''
模拟抢票软件需求:
并发查票与抢票
1.查看余票
2.开始抢票
进程互斥锁:
让并发变成串行, 牺牲了执行效率, 保证了数据安全.
在程序并发执行时,需要修改数据时使用.
'''
import json
import time
from multiprocessing import Process
from multiprocessing import Lock
# 查看余票
def search(user):
# 打开data文件查看余票
with open('data.txt', 'r', encoding='utf-8') as f:
dic = json.load(f)
print(f'用户{user}查看余票,还剩{dic.get("ticket_num")}...')
# 开始抢票
def buy(user):
# 先打开获取车票数据
with open('data.txt', 'r', encoding='utf-8') as f:
dic = json.load(f)
# 模拟网络延时
time.sleep(1)
# 若有票,修改data数据
if dic.get("ticket_num") > 0:
dic['ticket_num'] -= 1
with open('data.txt', 'w', encoding='utf-8') as f:
json.dump(dic, f)
print(f'用户: {user}抢票成功!')
else:
print(f'用户: {user}抢票失败!')
# 开始抢票
def run(user, mutex):
# 并发: 异步执行
search(user)
# 串行: 同步执行
# mutex.acquire()
buy(user)
# mutex.release()
if __name__ == '__main__':
# 调用Lock()类得到一个锁对象
mutex = Lock()
# 加锁:
# mutex.acquire()
# 释放锁:
# mutex.release()
# 同时来10个用户抢票
for i in range(10):
# 并发开启10个子进程
p = Process(target=run, args=(f'用户{i}', mutex))
p.start()
# p.join()
队列
队列: 先进先出
相当于内存中产生一个队列空间,
可以存放多个数据,但数据的顺序是由先进去的排在前面.
- 堆栈: 先进后出xxxxxxxxxx 队列: 先进先出 相当于内存中产生一个队列空间, 可以存放多个数据,但数据的顺序是由先进去的排在前面.- 堆栈: 先进后出队列: 先进先出 相当于内存中产生一个队列空间, 可以存放多个数据,但数据的顺序是由先进去的排在前面.- 堆栈: 先进后出
'''
队列: 先进先出
相当于内存中产生一个队列空间,
可以存放多个数据,但数据的顺序是由先进去的排在前面.
堆栈: 先进后出
'''
from multiprocessing import Queue
# 调用队列类,实例化队列对象 q
q = Queue(5) # 若传参队列中可以存放5个数据
# q1 = Queue() # 若不传参,队列中可以存放无限大的数据,前提硬件能更得上
# put添加数据,若队列中的数据满了,则卡住
q.put(1)
print('进入数据1')
q.put(2)
print('进入数据2')
q.put(3)
print('进入数据3')
q.put(4)
print('进入数据4')
q.put(5)
print('进入数据5')
# 查看队列是否满了
print(q.full()) # True
# 添加数据,若队列满了,则会报错
# q.put_nowait(6)
# q.get(): 获取的数据遵循 "先进先出",若队列中无数据可取,也会卡住
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
# print(q.get())
# get_nowait: 获取数据,队列中若没有,则会报错
# print(q.get_nowait())
# 判断队列是否为空
print(q.empty()) # False
q.put(6)
print('进入数据6')
q.put_nowait(7)
q.put_nowait(8)
q.put_nowait(9)
q.put_nowait(10)
IPC(进程间通信)
IPC(进程间通信):
进程间数据是相互隔离的,若想实现进程间通信,可以利用队列.
'''
IPC(进程间通信):
进程间数据是相互隔离的,若想实现进程间通信,可以利用队列.
'''
from multiprocessing import Process
from multiprocessing import Queue
def test1(q):
data = '数据hello'
q.put(data)
print('进程1开始添加数据到队列中..')
def test2(q):
data = q.get()
print(f'进程2从队列中获取数据{data}')
if __name__ == '__main__':
q = Queue()
p1 = Process(target=test1, args=(q, ))
p2 = Process(target=test2, args=(q, ))
p1.start()
p2.start()
print('主')
生产者与消费者
生产者与消费者:
生产者: 生产数据的
消费者: 使用数据的
- 生活中:
比如: 卖油条, 一边生产油条, 一边卖油条, 供需不平衡.
程序中:
通过队列,生产者把数据添加队列中,消费者从队列中获取数据.
'''
生产者与消费者:
生产者: 生产数据的
消费者: 使用数据的
生活中:
比如: 卖油条, 一边生产油条, 一边卖油条, 供需不平衡.
程序中:
通过队列,生产者把数据添加队列中,消费者从队列中获取数据.
'''
from multiprocessing import Queue, Process
import time
# 生产者
def producer(name, food, q): # 生产名, 食物, 队列
for i in range(9):
data = food, i
msg = f'用户{name}开始制作{data}'
print(msg)
q.put(data)
time.sleep(0.1)
# 消费者
def consumer(name, q):
while True:
data = q.get()
if not data:
break
print(f'用户{name}开始吃{data}')
if __name__ == '__main__':
q = Queue()
# # 创造生产者
p1 = Process(target=producer, args=('tank', '油条', q))
p2 = Process(target=producer, args=('华农兄弟', '竹鼠', q))
# 生产消费者
c1 = Process(target=consumer, args=('egon', q))
c2 = Process(target=consumer, args=('jason', q))
p1.start()
p2.start()
c1.daemon = True
c2.daemon = True
c1.start()
c2.start()
p2.join()
print('主')
线程
'''
1.什么是线程?
线程与进程都是虚拟单位,目的是为了更好地描述某种事物.
- 进程: 资源单位
- 线程: 执行单位
开启一个进程,一定会有一个线程,线程才是真正执行者.
2.为什么要使用线程?
节省内存资源.
- 开启进程:
1) 开辟一个名称空间,每开启一个进程都会占用一份内存资源.
2) 会自带一个线程
- 开启线程
1) 一个进程可以开启多个线程
2) 线程的开销远小于进程.
注意: 线程不能实现并行, 线程只能实现并发, 进程可以实现并行.
比喻: 内存就像一个工厂, 子进程就像一个工厂车间, 线程就像车间内的流水线.
'''
from threading import Thread
import time
# 开启线程方式1:
# def task():
# print('线程开启')
# time.sleep(1)
# print('线程结束')
#
#
# # t = Thread()
# if __name__ == '__main__':
# # 调用Thread线程类实例化得到线程对象
# t = Thread(target=task)
# t.start()
#
# 开启线程方式2:
class MyThread(Thread):
def run(self):
print('线程开启')
time.sleep(1)
print('线程结束')
t = MyThread()
t.start()
# if __name__ == '__main__':
# t = MyThread()
# t.start()
线程对象属性
from threading import Thread
from threading import current_thread
import time
def task():
print(f'线程开启{current_thread().name}')
time.sleep(3)
print(f'线程结束{current_thread().name}')
# t = Thread()
if __name__ == '__main__':
# 调用Thread线程类实例化得到线程对象
# for i in range(3):
# t = Thread(target=task)
# t.start()
# t = Thread(target=task)
# print(t.isAlive())
# t.daemon = True
# t.start()
# print(t.isAlive())
# print(t.is_alive())
t = Thread(target=task)
t.daemon = True
t.start()
print('主')
线程互斥锁
from threading import Thread
import time
'''
线程之间数据是共享的.
'''
# x = 100
# def task():
# print('开启线程...')
# time.sleep(1)
# global x
# x = 200
# print('关闭线程...')
#
#
# # t = Thread(target=task)
# # t.start()
# # print(x)
#
#
# if __name__ == '__main__':
# t = Thread(target=task)
# t.start()
# t.join()
# print(x)
# print('主')
# # for i in range(10):
# # t = Thread(target=task)
from threading import Thread, Lock
import time
mutex = Lock()
n = 100
def task(i):
print(f'线程{i}启动...')
global n
mutex.acquire()
temp = n
# time.sleep(0.1) # 一共等待10秒
n = temp-1
print(n)
mutex.release()
if __name__ == '__main__':
t_l=[]
for i in range(100):
t = Thread(target=task, args=(i, ))
t_l.append(t)
t.start()
for t in t_l:
t.join()
# 100个线程都是在100-1
print(n)