为真理而斗争是人生最大的乐趣。——布鲁诺
1 GIL锁:全局解释器锁,因为垃圾回收线程不是线程安全的,所有线程必须拿到这把锁,才能执行
2 GIL跟互斥锁的区别?GIL锁不能保证我们自己的数据安全,自己使用互斥锁保证自己的数据安全
3 不同线程数据交互两种方式:
-共享变量:不同线程修改同一份数据要加锁(互斥锁)
-通过queue:不需要考虑数据安全问题(线程安全了)
4 死锁现象:
-1 A线程拿到了A锁,等待B锁,B线程拿到了B锁,等待A锁,相互等待,永远等下去
-2 A线程拿到了A锁,再去拿A锁
5 递归锁(可重入锁):当前线程可以多次获得锁,每获得一次,计数器加一,每释放一次,计数器减一,只有计数器为0,其他线程才能获得
6 Event事件:(了解)
-event.set():发信号
-event.wait():阻塞等信号,只要收到set信号,就会继续往下执行
7 信号量:(了解),类似于锁,允许多条线程同时修改数据(有一些词,再不同环境下意思不一样)
8 Queue:三个:先进先出,后进先出,优先级 (线程Queue,跟进程的不是一个Queue)
9 池:池子,用来做缓冲
10 线程池:
from concurrent.futures import ThreadPoolExecutor
pool=ThreadPoolExecutor(5)
pool.submit(task,参数1,参数2).add_done_callback(回调函数)
# task执行完的数据如何给回调函数,回调函数会接收一个f对象,对象中有要的数据(task的return结果),f.result()
11 进程池同理,用法完全一样,只是换一个类
# 了解
from multiprocessing import Pool
p=Pool(3)
for url in urls:
p.apply_async(get_page,args=(url,),callback=pasrse_page)
12 并发:同一时间段内,多个任务执行(单核cpu可以实现),人跑步,鞋带开了,停下系鞋带,然后继续跑步,5分钟内,它干了两个事
并行:同一时刻,多个任务执行(单核cpu实现不了,必须多核),人跑步的同时听着歌
13 多核多线程比单核多线程更差,IO密集型用多线程,CPU(计算)密集型用多进程
# FastApi,django3.0,sanic,tornado:支持异步,有协程
1 线程池和进程池的shutdown
1 让主线程(进程)等待所有任务执行完成再执行
我们使用shutdown可以做到
2 如何实现呢?
利用进程池或者线程池的shutdown方法
3 shutdown方法的注意点:
- 放到for循环的外面,等待所有任务执行完成,主线程再继续走,如果放在for循环内部就会出现变成串行的问题
- shutdown方法的效果就是:等待所有任务完成,并且把进程(线程)池关闭
- 我们不可以在shutdown方法下面再去提交任务,会报错,应为进程(线程)池已经被关闭了
线程池是shutdown方法代码:
# 主线程等待所有任务执行完成
from concurrent.futures import ThreadPoolExecutor
import time
pool = ThreadPoolExecutor(3)
def task(name):
print('%s 开始'%name)
time.sleep(1)
print('%s 结束'%name)
if __name__ == '__main__':
for i in range(20):
pool.submit(task, '屌丝%s' % i)
pool.shutdown(wait=True)
#pool.submit(task,'sdddd')
print('主') # 立马执行,还是20个线程都执行完了,再执行
结果(部分):
屌丝0 开始
屌丝1 开始
屌丝2 开始
屌丝0 结束
屌丝3 开始
屌丝1 结束
屌丝4 开始
屌丝2 结束
屌丝5 开始
屌丝3 结束
屌丝6 开始
2 定时器
1 用定时器的目的是什么?
应用场景:想要指定多长时间之后执行一个任务
2 传参方式:
- t = Timer(2, task,kwargs={‘name’:‘lqz’})
- t = Timer(2, task,args=(‘lqz’,))
- 第一个位置:填写的是时间(也就是指定多长时间)
- 第二个位置:填写的是需要执行的任务(函数)
- 第三个位置:传参args=(),kwaegs={}
3 Timer的本质是什么?
- Timer的本质是线程。
执行代码:
# 多长时间之后执行一个任务
from threading import Timer
def task(name):
print('我是大帅比--%s'%name)
if __name__ == '__main__':
# t = Timer(2, task,args=('lqz',)) # 本质是开两个线程,延迟一秒执行
t = Timer(2, task,kwargs={'name':'lqz'}) # 本质是开两个线程,延迟一秒执行
t.start()
结果:
应为有延迟所以大家可以自行查看。
3 协程介绍
1 知识回顾:
我们现在所学习的有三种程分别是:进程,线程,协程
2 协程是用来干嘛的?
- 协程是为了实现单线程下的并发,属于线程下。
3 协程要解决的问题
- 需要协程自身,保存状态+切换,是并发的
4 如何解决保存状态并切换:
- 利用yield关键字:
- yield是什么?
- 生成器,只要函数中有yield关键字,这个函数就是生成器,通过yield可以实现保存状态+切换
实现代码:
5协程是什么?它的作用是什么?
- 协程并不是真是存在的某个东西,而是程序员臆想出来的
- 程序员控制,不让自己的程序遇到io,看上去,是实现并发了
# 通过yield,实现保存状态加切换(自定义的切换,并不是遇到io才切,所有它并不能节约时间)
# 单纯的切换,不但不会提高效率,反而会讲低效率
import time
def func1():
for i in range(100000000):
i += 1
yield
def func2():
g=func1() # 先执行一下func1
for i in range(100000000):
i += 1
next(g) # 回到func1执行
if __name__ == '__main__':
ctime = time.time()
func2()
print(time.time() - ctime) #14.764776706695557
我们可以把yield关键字删了还有那==next(g)和g=func()==删了
删了以后运行就是直接串行运行,这样可以看出我们的运行时间会短一半。
6 协程的优缺点有哪些:
- 优点如下:
协程的切换开销更小,属于程序级别的切换,操作系统完全感知不到,因而更加轻量级
单线程内就可以实现并发的效果,最大限度地利用cpu
- 缺点如下:
协程的本质是单线程下,无法利用多核,可以是一个程序开启多个进程,每个进程内开启多个线程,每个线程内开启协程
协程指的是单个线程,因而一旦协程出现阻塞,将会阻塞整个线程 - 总结协程特点:
必须在只有一个单线程里实现并发
修改共享数据不需加锁
用户程序里自己保存多个控制流的上下文栈(需要保存状态)
附加:一个协程遇到IO操作自动切换到其它协程(如何实现检测IO,yield、greenlet都无法实现,就用到了gevent模块(select机制))
4 greenlet模块
1 greenlet安装
- pip install greenlet (在正确的python解释器的pip目录下一般是在(E:\Python3.8.3\Scripts)这个是我的在此窗口的地址栏打上cmd直接就可以进入在这个文件位置下的cmd)
2 greenlet模块使用,的注意点:
- 遇到io不会切,需要程序员自己去设置切换的位置。
- 用于实现协程。
- .switch()来切换前面加上切换的目标函数。
实现代码:
from greenlet import greenlet
import time
def eat():
print('我吃了一口')
time.sleep(1)
# p.switch()
print('我又吃了一口')
# p.switch()
def play():
print('我玩了一会')
e.switch()
print('我又玩了一会')
if __name__ == '__main__':
e = greenlet(eat)
p = greenlet(play)
e.switch()
结果:
我吃了一口
我玩了一会
我又吃了一口
我又玩了一会
从结果我们可以看出我们已经有了一些实现了协程的方法了。
5 gevent模块
1 gevent安装
- pip install gevent(在正确的python解释器的pip目录下一般是在(E:\Python3.8.3\Scripts)这个是我的在此窗口的地址栏打上cmd直接就可以进入在这个文件位置下的cmd)
2 gevent模块使用,的注意点:
- gevent基于greenlet写的,实现了遇见io自动切换,也就是说不需要程序员自己去设置切换的位置。
- 用于实现协程。
- join()来启用前面加上启用的目标函数。
- 其中的==io操作time.sleep()需要调用模块内的 gevent.sleep() 也就是说其中的需要以这种io time操作才能实现协程之间相互切换的效果。
- 也可以用猴子补丁去实现。
from gevent import monkey;monkey.patch_all()
实现代码(使用了猴子补丁的情况下):
# 以后使用,这一句必须写
from gevent import monkey;monkey.patch_all()
import gevent
import time
def eat(name):
print('%s 吃了一口' % name)
time.sleep(1) # io操作,被猴子补丁替换之后,其实本身相当于gevent.sleep()
print('%s 又吃了一口' % name)
def play(name):
print('%s 玩了一会' % name)
time.sleep(2)
print('%s 又玩了一会' % name)
if __name__ == '__main__':
ctim = time.time()
e = gevent.spawn(eat,'lqz')
p = gevent.spawn(play,'lqz')
e.join() # 等待e执行完成
p.join()
print('主')
print(time.time() - ctim) #2.0165154933929443
结果:
有时间延迟,建议自己去查看结果。
6 单线程的套接字并发
作业
# 使用gevent实现单线程下的套接字并发效果
7 asyncio(了解就可以,这个是Python官方提供的。)
# 官方支持协程的库
# import time
# import asyncio
#
# # 把普通函数变成协程函数
# # 3.5以前这么写
# @asyncio.coroutine
# def task():
# print('开始了')
# yield from asyncio.sleep(1) #asyncio.sleep(1)模拟io
# print('结束了')
#
#
# loop=asyncio.get_event_loop() # 获取一个时间循环对象#
#
# # 协程函数加括号,并不会真正的去执行,它需要提交给loop,让loop循环着去执行
# # 协程函数列表
#
# ctime=time.time()
# t=[task(),task()]
# loop.run_until_complete(asyncio.wait(t))
# loop.close()
# print(time.time()-ctime)
import time
import asyncio
from threading import current_thread
# 表示我是协程函数,等同于3.5之前的装饰器
async def task():
print('开始了')
print(current_thread().name)
await asyncio.sleep(3) # await等同于原来的yield from
print('结束了')
async def task2():
print('开始了')
print(current_thread().name)
await asyncio.sleep(2)
print('结束了')
loop=asyncio.get_event_loop()
ctime=time.time()
t=[task(),task2()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)