python第三十八天，（线程回调，线程中的队列，事件，greentlet模块，gevent模块，自定义补丁） 单线程实现并发，协程
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了python第三十八天，（线程回调，线程中的队列，事件，greentlet模块，gevent模块，自定义补丁） 单线程实现并发，协程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8630字，纯文字阅读大概需要13分钟。
内容图文
1.线程回调
在线程池/进程池
每次提交任务，都会返回一个表示任务的对象，Future对象
Future对象具备一个绑定方法，add_done_callback 用于指定回调函数
add 意味着可以添加多个回调函数
如果直接使用Thread的话，如何完成回调
from threading import Thread
import time
def call_back(res):
print('任务结果拿到了：%s' % res)
def parser(res):
print('任务结果拿到了：%s' % res)
def task(parser):
print('run')
time.sleep(1)
res = 100 # 表示任务结果
parser(res) # 执行回调函数，并传入任务结果
t = Thread(target=task, args=(call_back,)) # 在这里指定parser也可以
t.start()
print('over')
View Code
2.线程中的队列
from queue import Queue,LifoQueue,PriorityQueue
# 与进程中的Joinablequeue使用方法一模一样，但是不具备IPC
# Queue 队列
# q = Queue()
#
# # 可以往里面添加数据
# q.put('123')
# q.put('456')
#
# # 可以获取数据
# print(q.get())
# print(q.get())
#
# # 获取值，设定取值时间，超时报错
# # print(q.get(block=True,timeout=3))
#
# # 告诉队列取值已经处理完毕
# q.task_done()
# q.task_done()
# # 等待队列为空后结束队列
# q.join()
# 输出结果
# 123
# 456
# LifoQueue,翻译为last in first out 后进先出，先进后出，模拟堆栈的模式
# 除了与Queue的队列不一样之外，其他的都一样
# lq = LifoQueue()
#
# lq.put('123')
# lq.put('456')
#
# print(lq.get())
# print(lq.get())
# 输出结果
# 456
# 123
# 具备优先级的队列
# PriorityQueue
# 可以存储一个可以比较大小的对象，对象越小，优先级越高，自定义对象不能使用比较运算符，所以不能存储
# q = PriorityQueue()
#
# q.put('b')
# q.put('a')
#
# print(q.get()) # 会优先得到a
View Code
3.事件 Event()
了解Event之前，我们先了解一个案例：
from threading import Thread, Event
import time
#
# is_running = False
# def boot_server():
# global is_running
# print('正在启动服务器。。。')
# time.sleep(3)
# print('服务器启动成功！')
# is_running = True
#
#
# def connect_server():
# while True:
# if is_running:
# print('连接服务器成功！')
# break
# else:
# time.sleep(0.5)
# print('error,服务器未启动')
#
#
# t1 = Thread(target=boot_server)
# t1.start()
#
# t2 = Thread(target=connect_server)
# t2.start()
View Code
案例：比如说我们做一个客户端连接服务器的模型，服务器与客户端同时启动 而客户端需要访问服务器，
而服务器启动需要时间，但是两个端口却是同时开启 所以客户端不能及时访问到服务器。
Event方法
python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法wait、clear、set
事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么执行event.wait 方法时便不再阻塞。
-
clear：将“Flag”设置为False
-
set：将“Flag”设置为True
用 threading.Event 实现线程间通信，使用threading.Event可以使一个线程等待其他线程的通知，我们把这个Event传递到线程对象中，
Event默认内置了一个标志，初始值为False。一旦该线程通过wait()方法进入等待状态，直到另一个线程调用该Event的set()方法将内置标志设置为True时，该Event会通知所有等待状态的线程恢复运行。
使用Event的案例：
from threading import Thread, Event
import time
# 而使用Event方法就可以解决这种问题
boot_event = Event()
# boot_event.clear() 恢复事件的状态为False
# boot_event.is_set() 返回事件的状态
# boot_event.wait() 等待事件发生，就是等待事件被设置为True
# boot_event.set() 设置事件为True
def boot_server():
print('正在启动服务器。。。')
time.sleep(3)
print('服务器启动成功')
boot_event.set() # 标记事件已经发生了，将状态设置为True
def connect_server():
boot_event.wait() # 等待事件发生,如果状态成为了True,会执行下面的代码
print('连接服务器成功！')
t1 = Thread(target=boot_server)
t1.start()
t2 = Thread(target=connect_server)
t2.start()
View Code
引子
上一节中我们知道GIL锁将导致CPython无法利用多核CPU的优势，只能使用单核并发的执行。很明显效率不高，那有什么办法能够提高效率呢？
效率要高只有一个方法就是让这个当前线程尽可能多的占用CPU时间，如何做到？
任务类型可以分为两种 IO密集型 和 计算密集型
对于计算密集型任务而言 ，无需任何操作就能一直占用CPU直到超时为止，没有任何办法能够提高计算密集任务的效率，除非把GIL锁拿掉，让多核CPU并行执行。
对于IO密集型任务任务，一旦线程遇到了IO操作CPU就会立马切换到其他线程，而至于切换到哪个线程，应用程序是无法控制的，这样就导致了效率降低。
如何能提升效率呢？想一想如果可以监测到线程的IO操作时，应用程序自发的切换到其他的计算任务，是不是就可以留住CPU？的确如此
一、单线程实现并发
单线程实现并发这句话乍一听好像在瞎说
首先需要明确并发的定义
并发：指的是多个任务同时发生，看起来好像是同时都在进行
并行：指的是多个任务真正的同时进行
早期的计算机只有一个CPU，既然CPU可以切换线程来实现并发，那么为何不能再线程中切换任务来并发呢？
上面的引子中提到，如果一个线程能够检测IO操作并且将其设置为非阻塞，并自动切换到其他任务就可以提高CPU的利用率，指的就是在单线程下实现并发。
如何能够实现并发呢
并发 = 切换任务+保存状态，只要找到一种方案，能够在两个任务之间切换执行并且保存状态，那就可以实现单线程并发
python中的生成器就具备这样一个特点，每次调用next都会回到生成器函数中执行代码，这意味着任务之间可以切换，并且是基于上一次运行的结果，这意味着生成器会自动保存执行状态！
案例：yiled实现并发效果
# 使用生成器来实现单线并发多个任务
import time
def func1():
a = 1
for i in range(1000000):
a += 1
print('a run')
time.sleep(3)
yield
def func2():
res = func1()
a = 1
for i in range(1000000):
a += 1
print('b run')
next(res)
st = time.time()
func2()
print(time.time() - st)
'''
对于纯计算的任务而言，单线程并发反而使执行效率下降了一半左右。所以这样的方案对于纯计算任务而言是没有必要的
我们暂且不考虑这样的并发对程序的好处是什么，在上述代码中。使用yield来切换代码结构非常混乱，如果任务太多，
而且每个都需要切换的话，那么会大大的增加时间。降低了效率，因此就有人专门对yield进行了封装，于是便有了greenlet模块
'''
View Code
2.greenlet模块
'''
一个'greenlet’是一个小型的独立伪线程，可以把它想象成一些栈帧，栈是初始调用的函数，而栈顶是当前'greenlet'的暂停位置
你使用'greenlet' 创建一堆这样的堆栈，然后在他们之间跳转执行。跳转必须显式声明的：一个greenlet必须选择要跳转到的另一个greenlet，
这会让前一个挂起，而后一个在此前挂起处恢复执行。不同greenlets之间的跳转称为切换(switching) 。
当你创建一个greenlet时，它得到一个开始时为空的栈；当你第一次切换到它时，它会执行指定的函数，这个函数可能会调用其他函数、切换跳出greenlet等等。
最终栈底的函数执行结束出栈时，这个greenlet的栈又变成空的，这个greenlet也就死掉了。greenlet也会因为一个未捕捉的异常死掉。
'''
import greenlet
import time
def task1():
print('task1,run')
g2.switch() # 切换任务至g2
print('task1 over')
g2.switch() # 切换任务至g2
def task2():
print('task2,run')
g1.switch() # 切换任务至g1
time.sleep(2)
print('task2,over')
g1 = greenlet.greenlet(task1)
g2 = greenlet.greenlet(task2)
g1.switch()
print('主 over')
'''
该模块简化了yield复杂的代码结构，实现了单线程下多任务并发，但是无论直接使用yield还是greenlet都不能检测到IO操作
如果遇到IO时同样进入阻塞状态，所以此时的并发是没有任何意义的
因此就延申出了gevent模块，既能检测IO，又能实现单线程并发，注意的是gevent模块自身无法检测IO
'''
View Code
协程·
协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。
需要强调的是：
1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）
对比操作系统控制线程的切换，用户在单线程内控制协程的切换
优点如下：
1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
2. 单线程内就可以实现并发的效果，最大限度地利用cpu
缺点如下：
1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程来尽可能提高效率
2. 协程本质是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
1.geven模块 协程的使用
import time
'''
gevent 不具备检测IO的能力，需要为它打补丁，打上补丁之后就能检测IO
注意补丁一定需要打在最上面，必须保证导入模块前就打好补丁
'''
from gevent import monkey
monkey.patch_all()
from threading import current_thread
import gevent
def task1():
# print(current_thread(), 1)
print('task1,run')
time.sleep(3)
print('task1 over')
def taks2():
# print(current_thread(), 2)
print('task2 run')
print('task2 over')
# spawn 用于创建一个协程任务
g1 = gevent.spawn(task1)
g2 = gevent.spawn(taks2)
# 任务要执行，必须保证主线程没挂，因为所有协程任务都是主线在执行
# 必须调用join来等待协程任务，理论上等待执行时间最长的任务，
# 但是我们在执行过程中并不知道那个任务执行的时间最长，所有全部join
# 这里有一个方法可以全部join,
gevent.joinall([g1,g2])
print('over')
View Code
monkey () 补丁
在Python语言中，monkey patch 指的是对于一个类或者模块所进行的动态修改
2.自定义补丁练习
import json
# 自定义json补丁
def dumps(obj):
print('这是打完补丁后的dumps函数 哈哈哈哈！')
def loads(json_str):
print('这是打完补丁后的loads函数 嘻嘻嘻嘻！')
def patch_json():
json.dumps = dumps
json.loads = loads
# 打补丁
patch_json()
# 再次调用会执行覆盖的dumps与loads方法
json.dumps('123123') # 输出结果 '这是打完补丁后的dumps函数 哈哈哈哈！'
json.loads('123321') # 输出结果 '这是打完补丁后的loads函数 嘻嘻嘻嘻！’
View Code
内容总结
以上是互联网集市为您收集整理的python第三十八天，（线程回调，线程中的队列，事件，greentlet模块，gevent模块，自定义补丁） 单线程实现并发，协程全部内容，希望文章能够帮你解决python第三十八天，（线程回调，线程中的队列，事件，greentlet模块，gevent模块，自定义补丁） 单线程实现并发，协程所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。