一.内容回顾
线程
锁
为什么有了GIL之后还需要锁
多个线程同时操作全局变量还需要锁
当出现'非原子性操作',例如+= -= *= /=
l.append(l) 原子性操作
a += 1 a= a+1
tmp = a +1
a = tmp
死锁现象
什么是死锁现象
两个以上的线程争抢同一把锁
其中一个线程获取到锁之后不释放
另外的其他线程就都被锁住了
比较容易出现问题的情况: 两把锁套在一起用了
死锁现象的本质 :代码逻辑问题
递归锁
一把锁在同一个线程中acquire多次而不被阻塞
如果另外的线程想要使用,必须release相同的次数
才能释放锁给其他线程
信号量
控制几个线程同一时刻只能有n个线程执行某一段代码
锁 + 计数器
事件
两件事情
一件事情要想执行依赖于另一个任务的结果
条件
n个线程在某处阻塞
由另一个线程控制这n个线程中有多少个线程能继续执行
定时器
规定某一个线程在开启之后的n秒之后执行
队列\栈\优先级队列
import queue
线程之间数据安全
多个线程get不可能同时取走一个数据,导致数据的重复获取
多个线程put也不可能同时存入一个数据,导致数据的丢失
队列 先进先出
栈 先进后出
优先级 优先级高的先出
线程池
concurrent.futrues
ThreadPoolExcuter
ProcessPoolExcuter
submit 异步提交任务
shutdown 等待池内任务完成
result 获取进程函数的返回值
map 异步提交任务的简便用法
add_done_callback 回调函数
进程 主进程执行
线程
今日内容
协程
基础概念
实现方式
扩展模块
第三方模块的安装
IO模型
IO多路复用
协程
进程 计算机中最小的资源分配单位
线程 计算机中能被CPU调度的最小单位
线程是由操作系统创建的,开启和销毁仍然占用一些时间
调度
1.一条线程陷入阻塞之后,这一整条线程就不能再做其他事情了
2.开启和销毁多条线程以及cpu在多条线程之间切换仍然依赖操作系统
你了解协程
了解
协程(纤程,轻型线程)
对于操作系统来说协程是不可见的,不需要操作系统调度
协程是程序级别的操作单位
协程效率高不高
和操作系统本身没有关系,和线程也没有关系
而是看程序的调度是否合理
协程指的只是在同一条线程上能够互相切换的多个任务
遇到io就切换实际上是我们利用协程提高线程工作效率的一种方式
切换 + 状态保存 yield
import time def consumer(res): '''任务1:接收数据,处理数据''' pass def producer(): '''任务2:生产数据''' res=[] for i in range(10000000): res.append(i) return res start=time.time() # res=producer() consumer(res) #写成consumer(producer())会降低执行效率 stop=time.time() print(stop-start)
import time def consumer(): while True: res = yield def producer(): g = consumer() next(g) for i in range(10000000): g.send(i) start =time.time() producer() print(time.time() - start) # yield这种切换 就已经在一个线程中出现了多个任务,这多个任务之前的切换 本质上就是协程,consumer是一个协程,producer也是一个协程 # 单纯的切换还会消耗时间 # 但是如果能够在阻塞的时候切换,并且多个程序的阻塞时间共享,协程能够非常大限度的提高效率
# greenlet 协程模块 在多个任务之间来回切换 import time from greenlet import greenlet def play(): print('start play') g2.switch() # 开关 time.sleep(1) print('end play') def sleep(): print('start sleep') time.sleep(1) print('end sleep') g1.switch() g1 = greenlet(play) g2 = greenlet(sleep) g1.switch() # 开关
start play
start sleep
end sleep
end play
gevent
gevent.spawn()”方法会创建一个新的greenlet协程对象，并运行它。”
gevent.joinall()”方法会等待所有传入的greenlet协程运行结束后再退出，
这个方法可以接受一个”timeout”参数来设置超时时间，单位是秒。
# gevent 基于greenlet实现的,多个任务交给gevent管理,遇到IO就使用greenlet进行切换
import time
import gevent def play(): # 协程1 print(time.time()) print('start play') gevent.sleep(1) print('end play') def sleep(): # 协程2 print('start sleep') print('end sleep') print(time.time()) g1 = gevent.spawn(play) g2 = gevent.spawn(sleep) # g1.join() # g2.join() # 精准的控制协程任务,一定是执行完毕之后join立即结束阻塞 gevent.joinall([g1,g2])
from gevent import monkey;monkey.patch_all() # 把下面所有的模块中的阻塞都打成一个包,然后gevent就可以识别这些阻塞事件了 import time import gevent def play(): # 协程1 print(time.time()) print('start play') time.sleep(1) print('end play') def sleep(): # 协程2 print('start sleep') time.sleep(1) print('end sleep') print(time.time()) g1 = gevent.spawn(play) g2 = gevent.spawn(sleep) gevent.joinall([g1,g2])
import time from gevent import monkey;monkey.patch_all() from urllib.request import urlopen import gevent url_lst = ['https://www.python.org/','https://www.yahoo.com/','https://github.com/'] def get_page(url): ret = urlopen(url).read().decode('utf-8') return ret start = time.time() g_l = [] for url in url_lst: g = gevent.spawn(get_page,url) g_l.append(g) gevent.joinall(g_l) print(time.time()-start)#2.8369998931884766
socket_server
from gevent import monkey;monkey.patch_all() import socket import gevent def talk(conn): while True: msg = conn.recv(1024).decode() conn.send(msg.upper().encode()) sk = socket.socket() sk.bind(('127.0.0.1',9000)) sk.listen() while True: conn,addr = sk.accept() gevent.spawn(talk,conn)
socket_server
import socket import threading def task(): sk = socket.socket() sk.connect(('127.0.0.1',9000)) while True: sk.send(b'hello') print(sk.recv(1024)) for i in range(500): threading.Thread(target=task).start()
总结
# 协程 # 一条线程在多个任务之间相互切换 # 数据安全的 # 不能利用多核 # 能够规避一个线程上的IO阻塞 # 一条线程能够起500个协程 # 4c的机器 # 5个进程 # 每一个进程20个线程 # 每一个线程500个协程 # 5*20*500 = 50000
IO模型
网络IO模型
阻塞IO 之前写的所有的socket recv阻塞 recvfrom accept
非租塞IO 能实现并发,浪费资源,并且麻烦
from socket import * s=socket(AF_INET,SOCK_STREAM)#socket（）是一个函数，创建一个套接字，AF_INET 表示用IPV4地址族，SOCK_STREAM 是说是要是用流式套接字 s.bind(('127.0.0.1',8080)) s.listen(5) s.setblocking(False) #设置socket的接口为非阻塞 conn_l=[] # 所有通话连接的列表 del_l=[] # # 1s 10000行代码 9998行都是异常处理 白白消耗了系统资源 while True: try: conn,addr=s.accept() # 如果有人链接我 我就直接通过连接 如果没人链接我 我就报错 conn_l.append(conn) # 如果有人连我,就获取到一个conn,并且把这个conn添加到conn_l except BlockingIOError: for conn in conn_l: # [conn1,conn2] try: data=conn.recv(1024) #尝试接收每一个和我连接的人的消息 if not data: # 如果对方已经断开连接了 del_l.append(conn) # 就把这个连接添加到del_l中 continue conn.send(data.upper()) # 对每一个发送给我的信息进行回复 except BlockingIOError: # 如果某个conn并没有消息来就会报错,被这个异常处理 pass except ConnectionResetError: # 如果对方已经断开连接了 del_l.append(conn) for conn in del_l: # 对于已经断开连接的这些conn [conn1] conn_l.remove(conn) # 从conn_l中移除这个连接 conn.close() # 关闭这个连接 del_l=[] # 将del_l置空
# IO多路复用 # 操作系统提供给你的 # 对于你的程序来说 : 是一个代理 # 帮助你监听所有的通信对象,是否有数据来到操作系统中 # 一旦有 就通知你 # 你再根据通知来接收相应的数据 # 你不需要一直循环着问每一个对象是否有信息来,而是阻塞等待,任意一个对象有信息来,我就接收 import select # io多路复用有好几种机制 : select poll epoll # 多个io对象,多个conn,sk # 一个conn占着一条网络连接的路 # 多个conn占着多条路 # 多个conn复用同一个线程的操作 # from socket import * # import select # # s=socket(AF_INET,SOCK_STREAM) # s.bind(('127.0.0.1',8081)) # s.listen(5) # s.setblocking(False) #设置socket的接口为非阻塞 # read_l=[s,] # while True: # r_l,w_l,x_l=select.select(read_l,[],[]) # print(r_l,read_l) # for ready_obj in r_l: # if ready_obj == s: # conn,addr=ready_obj.accept() #此时的ready_obj等于s # read_l.append(conn) # else: # try: # data=ready_obj.recv(1024) #此时的ready_obj等于conn # if not data: # ready_obj.close() # read_l.remove(ready_obj) # continue # ready_obj.send(data.upper()) # except ConnectionResetError: # ready_obj.close() # read_l.remove(ready_obj) # 异步IO # socketserver # selectors模块 + threading模块实现的
非阻塞io的client
#客户端 from socket import * c=socket(AF_INET,SOCK_STREAM) c.connect(('127.0.0.1',8081)) while True: msg=input('>>: ') if not msg:continue c.send(msg.encode('utf-8')) data=c.recv(1024) print(data.decode('utf-8'))