并发编程
并发编程
1.操作系统发展史
并发编程其实就是学习操作系统的发展史,也成为并发编程的发展史
阶段一：穿孔卡片
程序员把要写的东西在卡片上穿孔,然后一人插入一次，只有第一个程序员走了第二个程序员才能使用该计算机
好处：程序员一个人独占计算机
坏处：计算机利用率太低,浪费资源
阶段二：联机批处理系统
提前使用磁带存储多个程序员的程序,然后交给输入机用来缩短时间
好处：CPU工作效率提升,不用反复等待程序录入
阶段三：脱机批处理系统
远程操作,从输入机传到卫星机种,再通过高速磁带传给主机运算。然后再通过磁带传给卫星机，最后传给输入机
好处：极大提升了CPU利用率,也是现代计算机的雏形
总结：操作系统的发展史也可以看成是CPU利用率的发展史
2.多道技术
研究并发编程的前提是：计算机只有一个cpu/一个核
1)单道技术
所有的程序排队执行,耗时是所有程序耗时之和
2)多道技术
计算机利用cpu干活时,硬盘提前准备好一些数据提高效率，总耗时较短
3)多道技术特点
(1)切换
1.程序进入IO操作会切换
print、input、read、write、time.sleep等
2.程序长时间占用CPU会切换
由于要求只有一个cpu，所以要保证各程序雨露均沾
(2)保存状态
每次切换前记录当前执行状态，切回来时基于切换前的状态继续执行
eg: 一家饭店只有一个服务员,但是同时来了5桌客人。当客人停顿时他就去下一桌服务客人，如此反复。
#单道与多道举例
做饭耗时50min
洗衣耗时30min
烧水耗时10min
单道技术：50+30+10
多道技术：50
3.进程
1)进程理论
(1)什么是进程
程序：一堆躺在文件上的死代码
进程：正在被运行的程序
(2)进程的调度算法
当同时执行多个程序时有三个调度算法：
🍥1.先来先服务
谁先来就先服务谁,针对耗时短的程序不友好
🍥2.短作业优先服务
谁耗时短先服务谁,针对耗时长的程序不友好
🍥3.时间片轮转法+多级反馈队列(目前计算机在用的方法)
将固定的时间分成多份时间片，所有程序来了都平分一份
可能该时间内有程序运行结束了，没结束的去下一层继续平分多个时间片
如果此时又新增一个程序，那新增的程序优先级最高
2)进程的并行与并发
并行：多个进程必须同时执行才叫并行(单个cpu无法实现)
并发：多个进程看上去像同时执行的就叫并发(单个cpu可以利用多道技术实现)
所以只要并行那肯定属于并发，以后追求的程序都是高并发
1.我的网站能支持14亿并行量(高并行)
答：错,14亿cpu得多少钱？？
# 并行量必须要有对等的cpu才可以实现
2.我的网站能支持14亿并发量(高并发)
答：合理,比如12306
3)进程的三状态
就绪态：所有进程在被cpu执行前都必须先进入就绪态等着
运行态：cpu正在执行
阻塞态：进程运行过程中出现了IO操作,阻塞态无法直接进入运行态,需先进入就绪态
4)同步、异步、阻塞、非阻塞
同步异步：用来表达任务的提交方式
同步：提交一个任务请求后原地等待请求的返回结果,期间不做任何事,收到返回结果后才能提交下一个任务请求
异步：提交一个任务请求后不原地等待请求的返回结果，直接去提交下一个任务请求，有结果自动通知。
阻塞非阻塞：用来表达任务的执行状态
阻塞：阻塞态(进程运行过程中出现了IO操作,阻塞态无法直接进入运行态,需先进入就绪态)
非阻塞：就绪态、运行态
但是一般看到的是四种状态的结合使用
5)一般看到的是四种状态的结合使用
同步阻塞：提交任务请求后原地等待请求的返回结果,期间不做任何事且CPU也走了,程序进入阻塞态。(效率最低)
eg：饭店门口排队,过程中什么也不做,且服务员也在忙其他事。等排到我且服务员回来了我才能执行下一件事
同步非阻塞：提交任务请求后原地等待请求的返回结果,期间可以做其他事,且不处于阻塞态。(很少用)
eg：饭店门口排队,过程中可以做其他事,当排到我时服务员直接帮我安排。
异步阻塞：提交任务请求后不原地等待求情的返回结果,直接去提交下一个任务请求,但是程序在阻塞态要等待CPU回来。(很少用)
eg：饭店门口排队,在旁边座位上做其他事等着叫号,当叫到号时还得等服务员回来。
异步非阻塞：提交任务请求后不原地等待请求的返回结果,直接去提交下一个任务请求。且不处于阻塞态 (效率最高)
eg：饭店门口排队,在旁边座位上做其他事等着叫号,当叫到号时服务员直接帮我安排。
6)创建进程的多种方式
(1)鼠标双击软件图标
(2)代码创建进程
方法一：利用函数方法创建
from multiprocessing import Process # 多进程模块
import time
def task(name):
print(f'{name}在运行')
time.sleep(3)
print(f'{name}运行结束')
if __name__ == '__main__':
"""同步操作"""
# task('jason')
# print('主进程')
"""
运行结果：
jason在运行
jason运行结束
主进程
"""
"""异步操作"""
# 创建一个对象p
p = Process(target=task,args=('jason',)) # 位置参数 (注意元组)
#p = Process(target=task, kwargs={'name': 'jason'}) # 关键字参数 太麻烦一般不用
# 用对象p去创建子进程去执行task函数
p.start()
print('主进程')
"""
运行结果：
主进程
jason在运行
jason运行结束
"""
"""
在不同操作系统中创建进程底层原理不同：
windows： 类似于导模块,要有__main__启动脚本
mac/linux：类似于直接拷贝,不需要__main__启动脚本,为了兼容最好加上
如果没有__main__会报错
"""
方法二：利用面向对象方法创建
from multiprocessing import Process
import time
class MyProcess(Process):
def run(self):
print('run正在运行')
time.sleep(3)
print('run运行结束')
if __name__ == '__main__':
"""同步操作"""
# obj=MyProcess()
# obj.run()
# print('主进程')
"""
执行结果：
子进程正在运行
子进程运行结束
主进程
"""
"""异步操作"""
obj=MyProcess()
obj.start()
print('主进程')
"""
运行结果：
主进程
run正在运行
run运行结束
"""
如果有参数如何传：
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self, name):
super().__init__() # 由于重写了__init__方法 但是本身的name默认是有一个子进程名字的,所以需调用super()方法 然后再修改里面的name (如果super()放在下一行那么name就会变成子进程的名字)
# 子进程的名字：MyProcess-1
self.name = name
def run(self):
print(f'{self.name}在运行')
time.sleep(3)
print(f'{self.name}运行结束')
if __name__ == '__main__':
obj = MyProcess('jason')
obj.start()
print('主进程')
"""
运行结果：
主进程
jason在运行
jason运行结束
"""
7)进程间数据隔离
同一台计算机中的多个进程数据彼此间默认是互相隔离的
from multiprocessing import Process
money = 1000
def task():
global money
money = 666
print('子进程查看money：', money)
if __name__ == '__main__':
p = Process(target=task)
p.start() # 用对象p创建子进程去执行task函数
print('主进程查看money：', money)
"""
运行结果：
子进程查看money： 666
主进程查看money： 1000
"""
因为同一台计算机中多个进程数据彼此间是互相隔离的,所以虽然用了global修改全局变量,但还是没有真正去修改主进程中的money
8)进程join方法
调用join方法会让主进程变为同步操作,子进程还是异步 (主进程等子进程运行结束后再运行)
from multiprocessing import Process
import time
def task(name, n):
print(f'{name}正在运行')
time.sleep(n)
print(f'{name}运行结束')
if __name__ == '__main__':
"""异步操作"""
p = Process(target=task, args=('jason1', 1))
p.start()
# print('主进程')
# 运行结果： 主进程 jason在运行 jason运行结束
"""加了join让主进程变成同步操作"""
p.join() # 加了join()方法后则执行完子进程再执行主进程
print('主进程')
# 运行结果：jason在运行 jason运行结束 主进程
需注意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=('jason1', 1))
p2 = Process(target=task, args=('jason2', 2))
p3 = Process(target=task, args=('jason3', 3))
start_time=time.time()
p1.start()
p2.start()
p3.start() # 此时是三个进程同时启动
p1.join() # 等待1s
p2.join() # 等待1s(因为上一个进程已经走了1s)
p3.join() # 等待1s(因为上一个进程已经走了2s)
end_time=time.time()
print(f'总耗时：{end_time-start_time}')
print('主进程')
"""
运行结果：
jason1正在运行
jason2正在运行
jason3正在运行
jason1运行结束
jason2运行结束
jason3运行结束
总耗时：3.2788586616516113
主进程
"""
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=('jason1', 1))
p2 = Process(target=task, args=('jason2', 2))
p3 = Process(target=task, args=('jason3', 3))
start_time=time.time()
p1.start()
p1.join() # 等子进程1结束后再往下执行
p2.start()
p2.join() # 等子进程2结束后再往下执行
p3.start()
p3.join() # 等子进程3结束后再往下执行
end_time=time.time()
print(f'总耗时：{end_time-start_time}')
print('主进程')
"""
运行结果：
jason1正在运行
jason1运行结束
jason2正在运行
jason2运行结束
jason3正在运行
jason3运行结束
总耗时：6.6233131885528564
主进程
"""
9)IPC机制(进程间通信)
IPC:进程间通信(同一台计算机间多个进程可以互相交互)
消息队列：临时存储数据的地方 所有人都可以存 也可以取
队列：先进先出 堆栈：后进先出
IPC机制也可以理解为进程间可以基于该消息队列彼此交互 互相影响,打破了物理隔离
消息队列存在的意义就是为了存数据取数据,一般不需要判断有没有存满
# 【预备知识】：
from multiprocessing import Queue
# 创建队列对象
q = Queue(3) # 括号内不写默认是2147483647个数据数
# 1.put()往消息队列中添加数据
q.put(111)
q.put(222)
q.put(333)
# 2.full()判断消息队列是否已存满
print(q.full()) # True
# q.put(444) # 当超出存放极限,程序会处于阻塞态,不报错,直到消息队列中有数据被取出
# 3.get()从消息队列中取数据
# 4.get_nowait()从消息队列中取数据,如果没有了直接报错！
print(q.get()) # 111
print(q.get()) # 222
print(q.get()) # 333
# 5.empty()判断消息队列是否已空
print(q.empty()) # True
# print(q.get()) # 当超出获取极限,程序会处于阻塞态,不报错,直到队列中有数据被添加
"""
注意：
full() 和 empty() 在多进程下使用会失误
因为假如刚判断完队列有没有满 然后又添加了数据 此时打印出来没满 但是已经新放进去数据了 所以会失误
"""
验证主进程与子进程是否可以利用消息队列交互：
from multiprocessing import Process, Queue
def consume(q):
print('子进程获取消息队列中的数据：', q.get())
if __name__ == '__main__':
q = Queue()
p = Process(target=consume, args=(q,))
p.start()
q.put('主进程往消息队列中添加了该条数据')
print('主进程')
"""
主进程
子进程获取消息队列中的数据： 主进程往消息队列中添加了该条数据
"""
# 经过验证发现主进程往消息队列中添加的数据子进程也可以获取到
验证子进程与子进程是否可以利用消息队列交互
from multiprocessing import Process, Queue
def process1(q):
q.put('子进程1往消息队列中添加了该条数据')
def process2(q):
print('子进程2获取消息队列中的数据：', q.get())
if __name__ == '__main__':
q = Queue()
p1 = Process(target=process1, args=(q,))
p2 = Process(target=process2, args=(q,))
p1.start()
p2.start()
print('主进程')
"""
执行结果：
主进程
子进程2获取消息队列中的数据： 子进程1往消息队列中添加了该条数据
"""
# 经过验证发现子进程1往消息队列中添加的数据 子进程2也可以获取到
10)生产者消费者模型
生产者：负责产生数据的'人'
消费者：负责处理数据的'人'
完整的生产者与消费者模型要有三个部分：
生产者 消息队列 消费者
除了消息队列,只要能提供数据保存服务和提取服务的都可以(数据库、文件等)，主要目的就是中间存放数据
如果没有中间存放数据的地方,那生产者生产了一个数据就要马上给消费者,当生产者生产的速度很快,消费者拿数据又很慢时,生产者就得等消费者拿完再去生产,效率太低。所以需要有一个中间存放数据的地方。
11)进程对象的多种方法
#cmd命令查看进程号的方法： (PID 其实就是ProcessID)
tasklist
#进程号的目的：
方便管理各个进程
(1)查看进程号
print(current_process().pid) 查看自己的进程号
print(current_process()) 查看自己的进程信息
print(os.getpid()) 查看自己的进程号
print(os.getppid()) 查看进程的主进程号
# 方式一：用current_process模块
from multiprocessing import Process, current_process
def task():
print('子进程查看自己的信息：', current_process())
print('子进程查看进程号：', current_process().pid)
if __name__ == '__main__':
p1 = Process(target=task)
p1.start()
print('主进程查看自己的信息：', current_process())
print('主进程查看进程号：', current_process().pid)
"""
执行结果：
主进程查看自己的信息： <_MainProcess name='MainProcess' parent=None started>
主进程查看进程号： 20012
子进程查看自己的信息： <Process name='Process-1' parent=20012 started>
子进程查看进程号： 20576
"""
# 方式二：用os模块
from multiprocessing import Process
import os
def task():
print('子进程查看进程号：', os.getpid())
print('子进程查看主进程的进程号：', os.getppid())
if __name__ == '__main__':
p1 = Process(target=task)
p1.start()
print('主进程查看进程号：', os.getpid())
print('主进程查看主进程的进程号：', os.getppid())
# 因为是pycharm启动的进程,所以主进程中的进程号就是pycharm的进程号
"""
执行结果：
主进程查看进程号： 20364
子进程查看进程号： 11108
子进程查看主进程的进程号： 20364
"""
(2)终止进程
terminate() 终止进程
from multiprocessing import Process
import os
def task():
print('子进程查看自己的进程号：', os.getpid())
if __name__ == '__main__':
p = Process(target=task)
p.start()
p.terminate() # 终止子进程
print('主进程')
"""
执行结果：
主进程
"""
# 虽然执行了子进程,但是又终止了子进程,所以执行结果中没有子进程。如果在终止进程前加个等待时间则可以显示出子进程。
(3)判断进程是否存活
is_alive() 判断进程是否存活(需注意如果在终止后去判断,则需要在判断前加时间等待,给操作系统去终止的时间)
from multiprocessing import Process
import os
def task():
print('子进程查看自己的进程号：', os.getpid())
if __name__ == '__main__':
p = Process(target=task)
p.start()
p.terminate() # 终止子进程
print(p.is_alive()) # 判断子进程是否存活
print('主进程查看自己的进程号：', os.getpid())
"""
执行结果：
True
主进程查看自己的进程号： 16992
"""
# 由于终止子进程与判断子进程是否存活都是异步操作,此时提交给操作系统终止继承后还没来得及终止就打印了判断子进程是否存活,所以结果是True
# 如果想实现终止后再判断,则需要在判断是否存活前加个时间等待,等操作系统终止后再判断
(4)前面的start() 与 join()也是
12)守护进程
守护进程会随着守护的进程结束而立刻结束
注：设置守护进程的时候不能在启动了进程后设置,否则会报错
守护进程只有在做批量管理(如关闭)时会用到,也可以不用。
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=('torry',))
p.daemon=True # 将子进程变成守护进程
p.start()
# p.daemon=True # 不能启动了子进程再设置守护进程！！！
print('主进程')
"""
执行结果：
主进程
"""
13)僵尸进程和孤儿进程
僵尸进程：进程执行完毕后并不会立刻销毁所有数据,会有一些信息短暂保留下来
如：进程号、进程时间、进程消耗功率等。会把这些信息给父进程查看。需要父进程去参与回收
孤儿进程：子进程正常运行 父进程意外结束，那子进程就变成了孤儿进程。
操作系统针对孤儿进程会派遣类似父进程的机制来回收
14)多进程实现TCP服务端并发
服务端
import socket
from multiprocessing import Process
def task(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
sock.send('不在'.encode('utf8'))
if __name__ == '__main__':
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
while True:
sock, addr = server.accept()
p = Process(target=task, args=(sock,))
p.start()
客户端
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8080))
while True:
client.send('在吗'.encode('utf8'))
data = client.recv(1024)
print(data.decode('utf8'))
15)多进程数据错乱问题
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(f'{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(f'{name}买票成功')
else:
print(f'{name}很倒霉 没有抢到票')
def run(name):
search(name)
buy(name)
if __name__ == '__main__':
for i in range(3):
p = Process(target=run, args=(f'用户{i}',))
p.start()
"""
执行结果：
用户0在查票 当前余票为:0
用户1在查票 当前余票为:0
用户2在查票 当前余票为:0
用户2很倒霉 没有抢到票
用户0很倒霉 没有抢到票
用户1很倒霉 没有抢到票
"""
以上发现多进程在操作数据时可能会造成数据错乱问题，只有用互斥锁才可以完美解决
16)互斥锁
(1)什么是互斥锁
将并发/并行改为串行(类似单道)，牺牲了效率保障了数据的安全
除了有互斥锁，还有：行锁、表锁、乐观锁、悲观锁..等
(2)互斥锁如何使用
from multiprocessing import Lock # 导入互斥锁模块
mutex = Lock() # 产生锁
mutex.acquire() # 抢锁
# (操作数据代码)
mutex.release() # 释放锁
"""
注：
互斥锁之应该放在程序操作的上下,其他位置不要加 会让整个程序的效率特别低
"""
(3)互斥锁解决模拟抢票问题
from multiprocessing import Process,Lock
import time
import json
import random
# 查票
def search(name):
with open(r'data.json', 'r', encoding='utf8') as f:
data = json.load(f)
print(f'{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(f'{name}买票成功')
else:
print(f'{name}很倒霉 没有抢到票')
def run(name, mutex):
search(name)
mutex.acquire() # 抢锁
buy(name)
mutex.release() # 释放锁
if __name__ == '__main__':
mutex = Lock() # 产生一把锁
for i in range(3):
p = Process(target=run, args=(f'用户{i}', mutex))
p.start()
"""
执行结果：
用户0在查票 当前余票为:1
用户1在查票 当前余票为:1
用户2在查票 当前余票为:1
用户0买票成功
用户1很倒霉 没有抢到票
用户2很倒霉 没有抢到票
"""
4.线程
1)线程理论
进程：进程是资源单位，表示一块内存空间
线程：线程是执行单位，表示真正的代码指令
进程可以理解为车间 线程可以理解为流水线
一个进程内【至少会含有一个线程】！！！！
🍉1.一个进程内可以开设多个线程
🍉2.同一个进程下的多个线程数据是共享的
🍉3.创建进程的消耗远远大于创建线程
多进程：需要申请内存空间,拷贝全部代码,资源消耗大
多线程：不需要申请内存空间,不需要拷贝全部代码,资源消耗小
2)创建线程的多种方式
创建线程由于不需要拷贝全部代码,所以无论什么系统都不会出现反复操作的情况,也不需要在启动脚本中执行,不过为了兼容和统一,建议加上
由于创建线程需要的资源小,所以以下会发现子线程运行与主线程运行几乎是同时起来的
(1)利用函数方法创建
from threading import Thread
import time
def task(name):
print(f'{name}子线程正在运行')
time.sleep(3)
print(f'{name}子线程运行结束')
if __name__ == '__main__':
# 创建一个对象t
t = Thread(target=task, args=('jason',)) # 注意元组
# 用对象t去创建子线程 去执行task函数
t.start()
print('主线程')
"""
执行结果：
jason子线程正在运行
主线程
jason子线程运行结束
"""
(2)利用面向对象方法创建
from threading import Thread
import time
class MyThread(Thread):
def run(self):
print('子线程正在运行')
time.sleep(3)
print('子线程运行结束')
if __name__ == '__main__':
obj = MyThread()
obj.start()
print('主线程')
"""
执行结果：
子线程正在运行
主线程
子线程运行结束
"""
如果有参数如何传：
from threading import Thread
import time
class MyThread(Thread):
def __init__(self,name):
super().__init__() # 由于重写了__init__方法 但是本身的name默认是有一个子线程名字的,所以需调用super()方法 然后再修改里面的name (如果super()放在下一行那么name就会变成子线程的名字)
# 子线程的名字：MyThread-1
self.name = name
def run(self):
print(f'{self.name}子线程正在运行')
time.sleep(3)
print(f'{self.name}子线程运行结束')
if __name__ == '__main__':
obj = MyThread('jason')
obj.start()
print('主线程')
"""
执行结果：
jason子线程正在运行
主线程
jason子线程运行结束
"""
3)线程join方法
调用join方法会让主线程变为同步操作,子线程还是异步 (主线程等子线程运行结束后再运行)
同进程,join()的位置不同,执行的结果也不同
from threading import Thread
import time
def task():
print('子线程正在运行')
time.sleep(3)
print('子线程运行结束')
if __name__ == '__main__':
t = Thread(target=task)
t.start()
t.join() # 主线程等子线程结束后再执行
print('主线程')
"""
执行结果：
子线程正在运行
子线程运行结束
主线程
"""
4)同进程内多个线程数据共享
from threading import Thread
money = 1000
def task():
global money
money = 666
if __name__ == '__main__':
t = Thread(target=task)
t.start()
t.join() # 为了确保子线程运行完毕再查找money
print(money) # 666
以上得出：同一个进程中,不同线程中数据是共享的 线程修改了进程中的money
5)线程对象的多种方法
(1)查看线程名
print(current_thread().name) 查看自己的线程名
from threading import Thread, current_thread
def task(name):
print(f'子线程{name}查看了自己的线程名字：', current_thread().name)
# 利用for循环打开2个线程
for i in range(2):
t = Thread(target=task, args=(i,))
t.start()
print('主线程查看了自己的线程名字', current_thread().name)
"""
执行结果：
子线程0查看了自己的线程名字： Thread-1
子线程1查看了自己的线程名字： Thread-2
主线程查看了自己的线程名字： MainThread
"""
(2)查看进程号
os.getpid()查看自己的进程号
from threading import Thread, current_thread
import os
def task(name):
print(f'子线程{name}查看了自己的进程号：', os.getpid())
# 利用for循环打开2个线程
for i in range(2):
t = Thread(target=task, args=(i,))
t.start()
print('主线程查看了自己的进程号：', os.getpid())
"""
执行结果：
子线程0查看了自己的进程号： 6068
子线程1查看了自己的进程号： 6068
主线程查看了自己的进程号： 6068
"""
(3)统计进程下的线程数
from threading import Thread, active_count
import time
def task(name):
print(f'子线程{name}正在运行')
time.sleep(1)
print(f'子线程{name}运行结束')
for i in range(2):
t = Thread(target=task,args=(i,))
t.start()
t.join()
print('统计当前进程下存活的线程数：', active_count())
print('主线程')
"""
执行结果：
子线程0正在运行
子线程0运行结束
子线程1正在运行
子线程1运行结束
统计当前进程下存活的线程数： 1
主线程
"""
以上验证了当子线程运行结束后,进程中还是会保留一个线程！
from threading import Thread, active_count
import time
def task(name):
time.sleep(2)
print(f'子线程{name}正在运行')
time.sleep(1)
print(f'子线程{name}运行结束')
for i in range(2):
t = Thread(target=task,args=(i,))
t.start()
print('统计当前进程下存活的线程数：', active_count())
print('主线程')
"""
执行结果：
统计当前进程下存活的线程数： 3
主线程
子线程0正在运行
子线程1正在运行
子线程1运行结束
子线程0运行结束
"""
以上当去掉join，且在子线程前加上睡眠时间即可查看当前线程数
6)GIL全局解释器锁
# 预备知识：
"""
python解释器也是由编程语言写出来的：
Cpython 是用C写出来的
Jpython 是用Java写出来的
Pypython 是用python写出来的
ps:最常用的就是Cpython
"""
# 官方文档对GIL的解释：
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.
1.在Cpython解释器中全局解释器锁简称：GIL。
2.GIL本质也是一把互斥锁 让'同一个进程内多个线程无法同时执行'('关键')。
3.GIL的存在主要是因为Cpython解释器中内存管理(垃圾回收机制)不是安全的。
(1)GIL的特点
1.本质也是互斥锁
2.是Cpython解释器的特点 不是python语法的特点
3.GIL的存在让'同一个进程内多个线程无法同时执行',无法发挥多核优势
4.GIL的存在主要是因为Cpython解释器中垃圾回收机制不是安全的
5.GIL两种情况下会释放锁：
1)线程正常结束
2)线程进入IO操作
(2)验证GIL的存在
from threading import Thread
num = 10
def task():
global num
num -= 1
# 因为下面线程是异步操作,所以用列表存放每一个线程对象
t_list = []
for i in range(10):
t = Thread(target=task)
t.start()
t_list.append(t)
# 循环线程对象列表,同时在最后执行join方法
for t in t_list:
t.join()
# 等待所有线程运行结束后再查看num是多少
print(num) # 0
以下举例：由于GIL遇到IO操作就会释放锁
from threading import Thread
import time
num = 10
def task():
global num
count = num
time.sleep(0.5)
num = count - 1
# 因为下面线程是异步操作,所以用列表存放每一个线程对象
t_list = []
for i in range(10):
t = Thread(target=task)
t.start()
t_list.append(t)
# 循环线程对象列表,同时在最后执行join方法
for t in t_list:
t.join()
# 等待所有线程运行结束后再查看num是多少
print(num) # 9
(3)验证：既然有GIL是否还要自己加锁
提问：既然Cpython解释器中有GIL的存在,那么以后写代码是不是就不用操作锁了？
回答：错！GIL只能确保同进程内多线程数据不会被垃圾回收机制乱删,并不能确保程序里的数据是否安全。上面第二个例子验证了如果不自己加锁则会让数据错乱,本来应该每一个数值都基于上一个线程减的数再减1.
from threading import Thread, Lock
import time
num = 10
def task(mutex):
global num
mutex.acquire() # 抢锁
count = num
time.sleep(0.1)
num = count - 1
mutex.release() # 释放锁
mutex = Lock() # 创建锁
# 因为下面线程是异步操作,所以用列表存放每一个线程对象
t_list = []
for i in range(10):
t = Thread(target=task, args=(mutex,))
t.start()
t_list.append(t)
# 循环线程对象列表,同时在最后执行join方法
for t in t_list:
t.join()
# 等待所有线程运行结束后再查看num是多少
print(num) # 0
(4)python多线程是否有用
需分以下4种情况来判断
"""
单CPU / 多CPU
IO密集型(有IO操作) / 计算密集型(无IO操作)
"""
1.单CPU 且 IO密集型：
多进程：申请额外的内存空间,消耗更多资源
多线程：消耗资源相对较少,利用多道技术实现并发
# 多线程有优势
2.单CPU 且 计算密集型：
多进程：申请额外的内存空间,消耗更多资源(总耗时+申请空间+拷贝代码+切换)
多线程：消耗资源相对较少,利用多道技术实现并发(总耗时+切换)
# 多线程有优势
3.多CPU 且 IO密集型：
多进程：总耗时(单个进程的耗时+申请内存空间+拷贝代码)
多线程：总耗时(单个进程的耗时+IO操作时间)
# 多线程有优势
4.多CPU 且 计算密集型：
多进程：总耗时(单个进程的耗时)
多线程：总耗时(多个进程的综合)
# 多进程完胜
#计算密集型：多进程 与 多线程
from multiprocessing import Process
from threading import Thread
import os
import time
def work():
res = 1
for i in range(1, 100000):
res *= i
if __name__ == '__main__':
print(os.cpu_count()) # 12 查看当前计算机CPU个数
start_time = time.time()
# p_list = []
# for i in range(12):#一次性创建12个进程
# p = Process(target=work)
# p.start()
# p_list.append(p)
# for p in p_list:#确保所有的进程全部运行完毕
# p.join()
# print('总耗时:%s' % (time.time() - start_time))
'计算密集型-多进程 运行结果:总耗时:6.665070295333862'
t_list = []
for i in range(12):#一次性创建12个线程
t = Thread(target=work)
t.start()
t_list.append(t)
for t in t_list:#确保所有的线程全部运行完毕
t.join()
print('总耗时:%s' % (time.time() - start_time))
'计算密集型-多线程 运行结果:总耗时:28.145029306411743'
#IO密集型：多进程 与 多线程
from multiprocessing import Process
from threading import Thread
import os
import time
def work():
time.sleep(2) #模拟纯IO操作
if __name__ == '__main__':
print(os.cpu_count()) # 12 查看当前计算机CPU个数
start_time = time.time()
# p_list = []
# for i in range(100): # 一次性创建100个进程
# p = Process(target=work)
# p.start()
# for p in p_list: # 确保所有的进程全部运行完毕
# p.join()
# p_list.append(p)
# print('总耗时:%s' % (time.time() - start_time))
'IO密集型-多进程 运行结果:总耗时:2.979950428009033'
t_list = []
for i in range(100): # 一次性创建100个线程
t = Thread(target=work)
t.start()
t_list.append(t)
for t in t_list:
t.join()
print('总耗时:%s' % (time.time() - start_time))
'IO密集型-多线程 运行结果:总耗时:2.0314550399780273'
结论：
IO密集型：
多进程 :总耗时:2.979950428009033'
多线程 :总耗时:2.0314550399780273'
计算密集型：
多进程 :总耗时:6.665070295333862'
多线程 :总耗时:28.145029306411743'
(5)死锁现象
#死锁就是我想要你手上的锁,你想要我手上的锁,程序卡在这里动不了了
"""
就算掌握了互斥锁的使用
先抢锁 后释放锁
但是在实际项目尽量少用,一没用好就变成了死锁(项目中领导也不允许使用)
"""
from threading import Thread, Lock
import time
#产生AB两把锁
mutexA=Lock()
mutexB=Lock()
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
mutexA.acquire()#抢锁
print(f'{self.name}抢到了A锁')
mutexB.acquire()
print(f'{self.name}抢到了B锁')
mutexB.release()#释放锁
print(f'{self.name}释放了B锁')
mutexA.release()
print(f'{self.name}释放了A锁')
def func2(self):
mutexB.acquire()
print(f'{self.name}抢到了B锁')
time.sleep(1)
mutexA.acquire()
print(f'{self.name}抢到了A锁')
mutexA.release()
print(f'{self.name}释放了A锁')
mutexB.release()
print(f'{self.name}释放了B锁')
for i in range(10):
t = MyThread()
t.start()
(6)信号量
#信号量本质也是互斥锁 只不过它是一次性产生多把锁
"""
强调:
信号量在不同的知识体系中意思不同：
1.在并发编程中 信号量就是多把互斥锁
2.在django中 信号量指的是达到某个条件自动触发(中间件)
之前使用Lock产生的是单把锁
类似于单间厕所,一个人走了另一个才能进
信号量是一次性创建多把锁
类似于公共厕所,其中一个人走了另一个人才能进
"""
from threading import Thread, Semaphore
import time
import random
sp = Semaphore(5) # 一次性产生五把锁
class MyThread(Thread):
def run(self):
sp.acquire() # 抢锁
print(self.name)
time.sleep(random.randint(1, 3)) # 随机睡眠1~3秒
sp.release() # 释放锁
# 开10个线程
for i in range(10):
t = MyThread()
t.start()
(7)event事件
子进程\子线程之间可以彼此等待彼此
eg:
子A运行到某一个代码位置后发信号告诉子B开始运行
from threading import Thread, Event
import time
event = Event() # 类似于造了一个红绿灯
def light():
print('红灯 所有人都不能动')
time.sleep(3)
print('绿灯 踩油门冲啊!!!')
event.set()
def car(name):
print('%s正在等红灯' % name)
event.wait()
print('%s加油门 飙车了' % name)
t = Thread(target=light)
t.start()
for i in range(5):
t = Thread(target=car, args=('赛车%s' % i,))
t.start()
"""
执行结果：
红灯 所有人都不能动
赛车0正在等红灯
赛车1正在等红灯
赛车2正在等红灯
赛车3正在等红灯
赛车4正在等红灯
绿灯 踩油门冲啊!!!
赛车0加油门 飙车了
赛车4加油门 飙车了
赛车1加油门 飙车了
赛车2加油门 飙车了
赛车3加油门 飙车了
"""
5.进程池与线程池
# 问：在实际应用中是否可以无限制的开进程和线程
答：不可以! 因为硬件的发展赶不上软件，有'物理极限' 如果在编写代码的过程中无限制的创建进程或者线程可能会导致计算机崩溃
池：降低程序的执行效率 保证计算机硬件的安全
进程池：提前创建好固定个数的进程供程序使用 后续不会再创建
线程池：提前创建好固定个数的线程供程序使用 后续不会再创建
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from threading import current_thread
import os
import time
# pool = ThreadPoolExecutor(5) # 固定产生五个线程池
pool = ProcessPoolExecutor(5) # 固定产生五个进程池
def task(n):
# print(current_thread().name)
print(os.getpid())#获取当前进程号
# print(n)
time.sleep(1)
return '返回的结果'
def func(*args, **kwargs):
print('func', args, kwargs)
print(args[0].result())
if __name__ == '__main__':
for i in range(20):
# res = pool.submit(task,123) # 朝池子中提交任务(异步)
# print(res.result()) # 同步
# pool.submit(task, 123).add_done_callback(func)
"""
add_done_callback
异步回调:异步任务执行完成后有结果就会自动触发该机制
"""
pool.submit(task, 123).add_done_callback(func)
6.携程
进程:资源单位
线程:执行单位
并发:多个进程看上去像同时执行的就是并发
协程:单线程下实现并发(效率极高)
在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
实际上IO操作被自己写的代码检测 一旦有则立刻让代码执行别的
(该技术完全是程序员自己弄出来的 名字也是程序员自己起的)
核心:自己写代码完成切换+保存状态
import time
from gevent import monkey;
monkey.patch_all() # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn
def func1():
print('func1 running')
time.sleep(3)
print('func1 over')
def func2():
print('func2 running')
time.sleep(5)
print('func2 over')
if __name__ == '__main__':
start_time = time.time()
# func1()
# func2()
s1 = spawn(func1) # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
s2 = spawn(func2)
s1.join()
s2.join()
print(time.time() - start_time) # 8.01237154006958 协程 5.015487432479858
1)协程实现TCP服务端并发
import socket
from gevent import monkey;monkey.patch_all() # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn
def communication(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
sock.send(data.upper())
def get_server():
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
while True:
sock, addr = server.accept() # IO操作
spawn(communication, sock)
s1 = spawn(get_server)
s1.join()
