昨日回顾
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
# 主线程等待所有任务执行完成
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)
shutdown,表示: 等待所有的线程运行结束
等同于:所有进程都join()
# 放到for外面
pool.shutdown(wait=True) # 等待所有任务完成，并且把池关闭
# 问题，关了还能提交任务吗？不能再提交了
pool.submit(task,'sdddd')
print('主') # 立马执行，20个线程都执行完了，再执行
2 定时器
# 多长时间之后执行一个任务
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 协程介绍
# 进程，线程，协程
# 协程是为了实现单线程下的并发，属性线程下
# 协程要解决的问题：保存状态+切换
# yield：生成器，只要函数中有yield关键字，这个函数就是生成器，通过yield可以实现保存状态+切换
import time
# 串行执行
# def func1():
# for i in range(100000000):
# i += 1
#
#
# def func2():
# for i in range(100000000):
# i += 1
#
#
# if __name__ == '__main__':
# ctime = time.time()
# func1()
# func2()
# print(time.time() - ctime) # 7s多一些
# 通过yield，实现保存状态加切换（自定义的切换，并不是遇到io才切，所有它并不能节约时间）
# 单纯的切换，不但不会提高效率，反而会讲低效率
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
# 协程并不是真实存在的某个东西，而是程序员臆想出来的
# 程序员控制，不让自己的程序遇到io，看上去，就实现并发了
'''
优点如下：
协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
单线程内就可以实现并发的效果，最大限度地利用cpu
缺点如下：
协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
总结协程特点：
必须在只有一个单线程里实现并发
修改共享数据不需加锁
用户程序里自己保存多个控制流的上下文栈(需要保存状态)
附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））
'''
4 greenlet模块
from greenlet import greenlet
import time
# 遇到io不会切，初级模块，gevent模块基于它写的，处理io切换
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模块
一定要使用join(),否则不执行
e = gevent.spawn(eat,'lqz')
p = gevent.spawn(play,'lqz')
# e.join() # 等待e执行完成
# p.join()
gevent基于greenlet写的，实现了遇见io自动切换
# import gevent
# import time
#
# def eat(name):
# print('%s 吃了一口' % name)
# gevent.sleep(1) # io操作
# print('%s 又吃了一口' % name)
#
#
# def play(name):
# print('%s 玩了一会' % name)
# gevent.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
# 这个程序执行完成，最少需要多长时间 2s多一点
# ctim=time.time()
这样写的话, 就是串行执行
# eat('lqz')
# play('lqz')
# print(time.time()-ctim) # 3.0190377235412598
想要写成time.sleep() 这样的通用的形式的话, 需要用到猴子补丁,将 gevent用time伪装起来
# 猴子补丁
# 以后使用,这一句必须写
from gevent import monkey;monkey.patch_all()
import gevent
import time
def eat(name):
print('%s 吃了一口' % name)
# io操作，被猴子补丁替换之后，gevent.sleep()
time.sleep(1)
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
# class Monkey():
# def play(self):
# print('猴子在玩')
#
#
# class Dog():
# def play(self):
# print('狗子在玩')
# m=Monkey()
# m.play()
#
# m.play=Dog().play # 这个过程就叫猴子补丁，在程序运行过程中，动态修改
# m.play()
# 其他老师讲的
import json
import ujson
def monkey_patch_json():
json.__name__ = 'ujson'
json.dumps = ujson.dumps
json.loads = ujson.loads
monkey_patch_json()
# 其实用的是ujson
aa=json.dumps({'name':'lqz','age':19})
print(aa)
6 单线程的套接字并发
# 使用gevent实现单线程下的套接字并发效果
7 asyncio
# 官方支持协程的库
# 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 等同于原来的yield from
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()
# # 协程函数加括号，并不会真正的去执行，它需要提交给loop，让loop循环着去执行
# # 协程函数列表
t=[task(),task2()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)
7 io模型（重点，抽象，难，面试重点）
1 内存分为内核缓冲区和用户缓冲区（网络下载的资源，硬盘加载的资源，先放到内核缓冲区----》copy到应用程序的缓冲区，应用程序才能用这个数据）
2 io模型：
-阻塞io（BIO）
-非阻塞io（NIO）
-io多路复用（） select（windows支持，windows不支持epoll，官方不提供redis的window版本），poll，epoll（linux支持）
-异步io：
-信号驱动io(理论，不在考虑范围内)
补充虚拟环境
1 解决不同项目依赖的模块版本不同的问题
2 pycharm中创建项目时选择
-这个虚拟环境可不可以给其他项目使用（取决你是否选择）
-基于系统解释器当前状态还是纯净状态来创建虚拟环境
3 装模块：
-cmd窗口下：pip3 install flask （装在谁下，你一定要确认好）
-推荐你们用pycharm：setting---》那一套
-pycharm下的terminal下装（相当于cmd），比cmd好在，它有个提示
4 现在用了虚拟环境如何换到系统环境
4 环境变量的作用
-把一个路径加入到环境变量，以后该路径下的命令，可以再任意位置执行
==================================================================
协程:
1、(最原始的)通过yield关键字实现的 协程:
通过 yield关键字,实现 保存状态+切换
核心代码:
yield
g = task1()
next(g)
2、greenlet模块实现的 协程:
遇到io不会切
核心代码:
主线程中
switch的作用: 一个任务碰到switch时, 就从当前位置跳到 另一个任务的对应位置去
当程序没有到switch时, 则从头执行
e = greenlet(eat)
p = greenlet(play)
# 这两个switch
e.switch()
p.switch()
以上的遇到 I/O 都无法实现自动切换
-----------------分水岭: -----------------------------
以下的遇到实现了 遇到I/O 自动切换
3、gevent(基于greenlet写的)模块实现的 协程:
实现了遇见I/O自动切换
核心代码:
gevent.sleep() # 这里用time.sleep()不行, 需要用 gevent.sleep()
e = gevent.spawn(task1, 传入的参数) # 这是一个类方法, 这里相当于造了一个对象;(类方法 可以造出对象来)
e.join # 这里的join 是启动任务
4、官方支持协程的库 asyncio模块实现的 协程:
核心代码:
# 一旦碰到yield,就保存状态+切换
await : 相当于原来的 yield from
asyncio.sleep() :相当于 time.sleep()
函数前面加 asyncio ,表明这个函数是一个 协程函数
asyncio def task1():
...
# loop 事件循环,看成一个死循环(轮循, 轮流循环),将事件放在其中 循环起来,遇到I/O就执行其他的任务
# 获取一个事件循环对象 loop
loop = asyncio.get_event_loop()
# 协程函数列表, 放置 上面的协程函数
# 协程函数加括号并不会真正的去执行, 它需要提交给loop,让loop循环的去执行
t=[task1(),task2()]
run_until_complete(future对象)
asyncio.wait() 就是造一个future对象
loop.run_until_complete(asyncio.wait(t))
# 把这个循环关掉, 因为这是一个死循环,所以需要关掉
# loop.close()
死锁现象:第二种,解决:通过 递归锁解决
shutdown等效于 所有的进程 都join,即所有的任务都完成,并且把池关闭
如果不加的话,则主不是最后一个执行的语句
yield一下 暂停
next一下 才继续执行
协程:
在一个task中,遇到I/O,通过程序员人为的切换,到另外一个task, 使程序 不主动让出cpu
系统中的原有的模块,拿过来用
给其他的项目来用,只能是当前的项目来用
原来 一条 线程只能接待一个人
async 一条线程可以接待多个人
本文深入探讨并发编程的核心概念，包括GIL锁、互斥锁、死锁、递归锁、事件、信号量、线程池、进程池、协程、greenlet及gevent模块的应用，详解异步IO模型及asyncio库的使用，旨在帮助读者掌握并发编程的精髓。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
