Python进阶----异步同步,阻塞非阻塞,线程池(进程池)的异步+回调机制实行并发, 线程队列(Queue, LifoQueue,PriorityQueue), 事件Event,线程的三个状态(就
Python进阶----异步同步,阻塞非阻塞,线程池(进程池)的异步+回调机制实行并发, 线程队列(Queue, LifoQueue,PriorityQueue), 事件Event,线程的三个状态(就绪,挂起,运行) ,***协程概念,yield模拟并发(有缺陷),Greenlet模块(手动切换),Gevent(协程并发)
一丶同步,异步
同步:
所谓同步就是一个任务须要依赖另外一个任务时,只有被依赖任务执行完毕以后,依赖的任务才会完成.这是可靠的任务序列.要么都成功,要么失败,两个任务的状态能够保持一致.html
异步:
所谓异步不须要等待被依赖的任务完成,只是通知依赖的任务要完成什么工做.依赖的任务也当即执行,只要本身完成了整个任务就算完成了. 至于被依赖的任务是否完成,依赖它的任务没法肯定,是不可靠的任务序列python
### 同步和异步 ## 好比我去银行办理业务，可能会有两种方式： # 第一种 ：选择排队等候； # 第二种 ：选择取一个小纸条上面有个人号码，等到排到我这一号时由柜台的人通知我轮到我去办理业务了； # 第一种：前者(排队等候)就是同步等待消息通知，也就是我要一直在等待银行办理业务状况； # 第二种：后者(等待别人通知)就是异步等待消息通知。在异步消息处理中，等待消息通知者(在这个例子中就是等待办理业务的人)每每注册一个回调机制，在所等待的事件被触发时由触发机制(在这里是柜台的人)经过某种机制(在这里是写在小纸条上的号码，喊号)找到等待该事件的人。
二丶阻塞,非阻塞,
阻塞和非阻塞两个概念与程序(也就是执行程序的'线程')等待消息通知时的状态相关git
阻塞:
在程序中,阻塞表明程序'卡'在某处,必须等待这处执行完毕才能继续执行.一般的阻塞大多数是IO阻塞github
好比:银行排队取钱是一条流水线,如今负责取钱的服务人员饿了,他必须吃饭(阻塞). 只有吃完饭才能继续回来服务你.此时你就必须等待他,不然你将没法取钱.对于程序而言,就卡在了此处.编程
非阻塞:
非阻塞就是没有IO阻塞,线程在执行任务时没有遇到IO阻塞.服务器
好比:你去银行取钱,在排队'等候'时什么事情都没有发生. 强调在执行的过程网络
同步阻塞:
效率最低.你排着队取钱,服务人员吃饭去了(阻塞了),此时你只能等待,不然不能取钱.这就是同步+阻塞数据结构
异步阻塞:
在银行等待办理业务的人,采用异步方式. 可是他不能离开银行并发
异步操做是能够被阻塞住的，只不过它不是在处理消息时阻塞，而是在等待消息通知时被阻塞。app
同步非阻塞:
其实是效率低下的。
想象一下你一边打着电话一边还须要抬头看到底队伍排到你了没有，若是把打电话和观察排队的位置当作是程序的两个操做的话，这个程序须要在这两种不一样的行为之间来回的切换，效率可想而知是低下的。
异步非阻塞:
效率更高
由于打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不一样的操做中来回切换。
好比说，这我的忽然发觉本身烟瘾犯了，须要出去抽根烟，因而他告诉大堂经理说，排到我这个号码的时候麻烦到外面通知我一下，那么他就没有被阻塞在这个等待的操做上面，天然这个就是异步+非阻塞的方式了。
不少人会把同步和阻塞混淆，是由于不少时候同步操做会以阻塞的形式表现出来，一样的，不少人也会把异步和非阻塞混淆，由于异步操做通常都不会在真正的IO操做处被阻塞。
三丶异步+回调机制
提升效率版:
####### 并发爬取 , 并发处理爬取结果
# 缺点: 1.加强了耦合性,
# 2.开启进程耗费资源
# 优势: 1. 提升处理效率
from concurrent.futures import ProcessPoolExecutor
import time
import random
import os
import requests
def get_html(url):
response=requests.get(url)
print(f'{os.getpid()} 正在爬取网页~~~')
if response.status_code==200:
parser_html(response.text)
def parser_html(obj):
print(f'总字符长度:{len(obj.result()) }')
if __name__ == '__main__':
url_list = [
'http://www.taobao.com',
'http://www.JD.com',
'http://www.JD.com',
'http://www.JD.com',
'http://www.baidu.com',
'https://www.cnblogs.com/jin-xin/articles/11232151.html',
'https://www.cnblogs.com/jin-xin/articles/10078845.html',
'http://www.sina.com.cn',
'https://www.sohu.com',
'https://www.youku.com',
]
pool=ProcessPoolExecutor(4) # 开启了一个进程池 有4个进程资源
for url in url_list:
obj=pool.submit(get_html,url) # 异步的开启了 10个任务,4个进程并行(并发)执行.
pool.shutdown(wait=True) # 必须等待全部的子进程任务执行完毕
下降耦合版本:
# 并发爬取, 串行解析结果
########### 回调函数 + 异步
# 1. 下降了耦合性, 由回调函数 去通知执行下一个任务(形成这个任务会经历串行)
# 2. 处理爬取结果时是串行处理,影响效率
import requests
from concurrent.futures import ProcessPoolExecutor
from multiprocessing import Process
import time
import random
import os
def get(url):
response = requests.get(url)
print(f'{os.getpid()} 正在爬取:{url}')
# time.sleep(random.randint(1,3))
if response.status_code == 200:
return response.text
def parse(obj):
'''
对爬取回来的字符串的分析
简单用len模拟一下.
:param text:
:return:
'''
time.sleep(1)
### obj.result() 取得结果
print(f'{os.getpid()} 分析结果:{len(obj.result())}')
if __name__ == '__main__':
url_list = [
'http://www.taobao.com',
'http://www.JD.com',
'http://www.JD.com',
'http://www.JD.com',
'http://www.baidu.com',
'https://www.cnblogs.com/jin-xin/articles/11232151.html',
'https://www.cnblogs.com/jin-xin/articles/10078845.html',
'http://www.sina.com.cn',
'https://www.sohu.com',
'https://www.youku.com',
]
start_time = time.time()
pool = ProcessPoolExecutor(4)
for url in url_list:
obj = pool.submit(get, url)
obj.add_done_callback(parse) # 增长一个回调函数
# 如今的进程完成的仍是网络爬取的任务,拿到了返回值以后,结果丢给回调函数add_done_callback,
# 回调函数帮助你分析结果
# 进程继续完成下一个任务.
pool.shutdown(wait=True)
print(f'主: {time.time() - start_time}')
四丶线程队列
使用 queue 模块
先进先出:FIFO
Queue
# -*-coding:utf-8-*-
# Author:Ds
import queue
q = queue.Queue(3) # 先进先出队列
q.put(1)
q.put(2)
q.put('123')
# q.put(666) # 阻塞 卡住了
# q.put(timeout=1) # 超时1秒报错 queue.Full
# q.put(1,block=False) # 非阻塞,直接报错 queue.Full
print(q.get())
print(q.get())
print(q.get())
# print(q.get()) #阻塞 卡住
# print(q.get(timeout=1)) #超时1秒报错 queue.Empty
print(q.get(block=False)) #非阻塞,直接报错queue.Empty
先进后出(后进先出):LIFO
LifoQueue
# -*-coding:utf-8-*-
# Author:Ds
import queue
q = queue.LifoQueue(3) #后进先出队列 (栈)
q.put(1)
q.put(2)
q.put('123')
# q.put(666) # 阻塞 卡住了
## q.put(timeout=1) # 超时1秒报错 queue.Full
### q.put(1,block=False) # 非阻塞,直接报错 queue.Full
print(q.get())
print(q.get())
print(q.get())
# print(q.get()) #阻塞 卡住
## print(q.get(timeout=1)) #超时1秒报错 queue.Empty
### print(q.get(block=False)) #非阻塞,直接报错queue.Empty
# 使用列表数据结构模拟栈 li=[] li.append(1) # 后进 添加元素到列表末尾 li.pop() # 先出 移除列表末尾元素
优先级队列:
PriorityQueue
# -*-coding:utf-8-*- # Author:Ds import queue q = queue.PriorityQueue(3) # 优先级队列 # 放入元组类型()数据, 第一个参数表示优先级别,第二个参数是真实数据 # 数字越低表示优先级越高 q.put((10, '垃圾消息')) q.put((-9, '紧急消息')) q.put((3, '通常消息')) # q.put((3, '我被卡主了 ')) # 卡主了 # q.put((3, '我被卡主了 '),timeout=1) # 超时报错: queue.Full q.put((3, '我被卡主了 '),block=False) # 不阻塞: queue.Full print(q.get()) print(q.get()) print(q.get()) print(q.get()) #阻塞 卡住 print(q.get(timeout=1)) #超时1秒报错 queue.Empty print(q.get(block=False)) #非阻塞,直接报错queue.Empty
五丶事件Event
线程的一个关键特性是每一个线程都是独立运行且状态不可预测。若是程序中的其 他线程须要经过判断某个线程的状态来肯定本身下一步的操做,这时线程同步问题就会变得很是棘手。为了解决这些问题,咱们须要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它容许线程等待某些事件的发生。在 初始状况下,Event对象中的信号标志被设置为假。若是有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程若是将一个Event对象的信号标志设置为真,它将唤醒全部等待这个Event对象的线程。若是一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
方法:
event.isSet()：返回event的状态值；
event.wait()：若是 event.isSet()==False将阻塞线程；
event.set()：设置event的状态值为True,全部阻塞池的线程激活进入就绪状态,等待操做系统调度；
event.clear()：恢复event的状态值为False
import time
from threading import Thread
from threading import current_thread
from threading import Event
event = Event() # 默认是False
def task():
print(f'{current_thread().name} 检测服务器是否正常开启....')
time.sleep(3)
event.set() # 改为了True
def task1():
print(f'{current_thread().name} 正在尝试链接服务器')
# event.wait() # 轮询检测event是否为Ｔrue,当其为True,继续下一行代码. 阻塞.
event.wait(1)
# 设置超时时间,若是1s中之内,event改为True,代码继续执行.
# 设置超时时间,若是超过1s中,event没作改变,代码继续执行.
print(f'{current_thread().name} 链接成功')
if __name__ == '__main__':
t1 = Thread(target=task1,)
t2 = Thread(target=task1,)
t3 = Thread(target=task1,)
t = Thread(target=task)
t.start()
t1.start()
t2.start()
t3.start()
红绿灯Event事件模型:
# _*_coding:utf-8_*_
# Author :Ds
# CreateTime 2019/5/30 17:54
import threading ,time
event=threading.Event() # 声明一个event全局变量
def lighter():
count=0 #计数
event.set() #设置有标志
while True: #循环
if count > 5 and count<10:# 红灯5秒
event.clear()# 清空标志位
print("\033[41;1mred light is on...\033[0m")
elif count>10: # 绿灯5秒
event.set()#变绿灯
count=0 #清空count
else:
print('\033[42;1mgreen light is on...\033[0m')
time.sleep(1)
count+=1
def car(name):
while True:
if event.is_set(): #is_set 判断设置了标志位没有
print('[%s] running ...'%name)
time.sleep(1)
else:
print(' [%s] see red light waiting '%name)
event.wait()
print('\033[43;lm [%s] green light is on ,start going ..\033[0m'%name)
light=threading.Thread(target=lighter,)
car1=threading.Thread(target=car,args=('特斯拉',))
car2=threading.Thread(target=car,args=('奔驰',))
light.start()
car1.start()
car2.start()
六丶协程
进程是资源分配的最小单位,线程是CPU调度的最小单
并发的本质：切换+保存状态
线程也具备三个状态:
cpu正在运行一个任务，会在两种状况下切走去执行其余的任务（切换由操做系统强制控制），一种状况是该任务发生了阻塞，另一种状况是该任务计算的时间过长
ps：在介绍进程理论时，说起进程的三种执行状态，而线程才是执行单位，因此也能够将上图理解为线程的三种状态
yield模拟并发:
1. yiled能够保存状态，yield的状态保存与操做系统的保存线程状态很像，可是yield是代码级别控制的，更轻量级
2. send能够把一个函数的结果传给另一个函数，以此实现单线程内程序之间的切换
一：其中第二种状况并不能提高效率，只是为了让cpu可以雨露均沾，实现看起来全部任务都被“同时”执行的效果，若是多个任务都是纯计算的，这种切换反而会下降效率。为此咱们能够基于yield来验证。yield自己就是一种在单线程下能够保存任务运行状态的方法，咱们来简单复习一下：
'''
一、协程：
单线程实现并发
在应用程序里控制多个任务的切换+保存状态
优势：
应用程序级别速度要远远高于操做系统的切换
缺点：
多个任务一旦有一个阻塞没有切，整个线程都阻塞在原地
该线程内的其余的任务都不能执行了
一旦引入协程，就须要检测单线程下全部的IO行为,
实现遇到IO就切换,少一个都不行，觉得一旦一个任务阻塞了，整个线程就阻塞了，
其余的任务即使是能够计算，可是也没法运行了
二、协程序的目的：
想要在单线程下实现并发
并发指的是多个任务看起来是同时运行的
并发=切换+保存状态
'''
#串行执行
import time
def func1():
for i in range(10000000):
i+1
def func2():
for i in range(10000000):
i+1
start = time.time()
func1()
func2()
stop = time.time()
print(stop - start)
#基于yield并发执行
import time
def func1():
while True:
yield
def func2():
g=func1()
for i in range(10000000):
i+1
next(g)
start=time.time()
func2()
stop=time.time()
print(stop-start)
# 单纯地切换反而会下降运行效率
二：第一种状况的切换。在任务一遇到io状况下，切到任务二去执行，这样就能够利用任务一阻塞的时间完成任务二的计算，效率的提高就在于此。
import time
def func1():
while True:
print('func1')
yield
def func2():
g=func1()
for i in range(10000000):
i+1
next(g)
time.sleep(3)
print('func2')
start=time.time()
func2()
stop=time.time()
print(stop-start)
yield不能检测IO，实现遇到IO自动切换
协程介绍:
协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。
一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序本身控制调度的。
须要强调的是:
#1. python的线程属于内核级别的，即由操做系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其余线程运行） #2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操做系统）控制切换，以此来提高效率（！！！非io操做的切换与效率无关）
优势以下：
1.协程的切换开销更小，属于程序级别的切换，操做系统彻底感知不到，于是更加轻量级
2.单线程内就能够实现并发的效果，最大限度地利用cpu
缺点以下：
1.协程的本质是单线程下，没法利用多核，能够是一个程序开启多个进程，每一个进程内开启多个线程，每一个线程内开启协程
2.协程指的是单个线程，于是一旦协程出现阻塞，将会阻塞整个线程
总结协程特色：
1.必须在只有一个单线程里实现并发
2.修改共享数据不需加锁
3.用户程序里本身保存多个控制流的上下文栈
4.附加：一个协程遇到IO操做自动切换到其它协程（如何实现检测IO，yield、greenlet都没法实现，就用到了gevent模块（select机制））
Greenlet模块:手动模拟切换
安装 ：pip3 install greenlet
手动实现切换
from greenlet import greenlet
def eat(name):
print('%s eat 1' %name)
g2.switch('egon')
print('%s eat 2' %name)
g2.switch()
def play(name):
print('%s play 1' %name)
g1.switch()
print('%s play 2' %name)
g1=greenlet(eat)
g2=greenlet(play)
g1.switch('egon') #能够在第一次switch时传入参数，之后都不须要
效率对比:
greenlet只是提供了一种比generator更加便捷的切换方式，当切到一个任务执行时若是遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提高效率的问题。
### 串行执行计算密集型~~ 11.37856674194336
import time
def f1():
res=1
for i in range(100000000):
res+=i
def f2():
res=1
for i in range(100000000):
res*=i
start_time=time.time()
f1()
f2()
print(f'runing time {time.time()-start_time}') # runing time 11.37856674194336
### 切换执行计算密集型~~ runing time 60.24287223815918
from greenlet import greenlet
import time
def f1():
res=1
for i in range(100000000):
res+=i
g2.switch()
def f2():
res=1
for i in range(100000000):
res*=i
g1.switch()
start_time=time.time()
g1=greenlet(f1)
g2=greenlet(f2)
g1.switch()
print(f'runing time {time.time()-start_time}') # runing time 60.24287223815918
Gevent模块:
安装：pip3 install gevent
Gevent 是一个第三方库，能够轻松经过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet所有运行在主程序操做系统进程的内部，但它们被协做式地调度
### 用法 g1=gevent.spawn(func,1,,2,3,x=4,y=5)建立一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面能够有多个参数，能够是位置实参或关键字实参，都是传给函数eat的 g2=gevent.spawn(func2) g1.join() #等待g1结束 g2.join() #等待g2结束 #或者上述两步合做一步：gevent.joinall([g1,g2]) g1.value#拿到func1的返回值
遇到IO阻塞时会自动切换任务
import gevent
def eat(name):
print('%s eat 1' %name)
gevent.sleep(2)
print('%s eat 2' %name)
def play(name):
print('%s play 1' %name)
gevent.sleep(1)
print('%s play 2' %name)
g1=gevent.spawn(eat,'egon')
g2=gevent.spawn(play,name='egon')
g1.join()
g2.join()
#或者gevent.joinall([g1,g2])
print('主')
'打补丁:monkey'
# from gevent import monkey
# monkey.patch_all() 必须放到被打补丁者的前面，
import threading
from gevent import monkey
monkey.patch_all() # 打补丁,自动切换
import gevent
import time
def eat():
print(threading.current_thread().getName()) # 虚拟线程 DummyThread-n
print('eat food 1')
time.sleep(2)
print('eat food 2')
def play():
print(threading.current_thread().getName()) # 虚拟线程 DummyThread-n
print('play 1')
time.sleep(1)
print('play 2')
g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2]) # 执行g1 g2
print(threading.current_thread().getName()) # MainThread 主线程
print('主')
协程应用:爬虫:
from gevent import monkey;monkey.patch_all()
import gevent
import requests
import time
def get_page(url):
print('GET: %s' %url)
response=requests.get(url)
if response.status_code == 200:
print('%d bytes received from %s' %(len(response.text),url))
start_time=time.time()
gevent.joinall([
gevent.spawn(get_page,'https://www.python.org/'),
gevent.spawn(get_page,'https://www.yahoo.com/'),
gevent.spawn(get_page,'https://github.com/'),
])
stop_time=time.time()
print('run time is %s' %(stop_time-start_time)) # 使用协程爬取,计算爬取的时间
- 1. 并发-0-同步/异步/阻塞/非阻塞/进程/线程
- 2. 进程| 线程 | 阻塞 | 阻塞&非阻塞 和 同步&异步
- 3. python－并行＆并发｜同步＆异步｜异步阻塞＆异步非阻塞＆同步阻塞＆同步非阻塞
- 4. 同步,异步,阻塞,非阻塞,异步加回调机制,线程队列,event事件
- 5. 线程与进程，阻塞非阻塞，同步与异步
- 6. 读懂进程线程、同步异步、阻塞非阻塞、并发并行
- 7. 进程线程、同步异步、阻塞非阻塞、并发并行
- 8. 并发编程-进程-05同步异步阻塞非阻塞
- 9. python系列——多线程之（同步、异步、阻塞、非阻塞）
- 10. GIL，同步异步，阻塞非阻塞
- 更多相关文章...
- • C# 多线程 - C#教程
- • Rust 并发编程 - RUST 教程
- • 漫谈MySQL的锁机制
- • Java 8 Stream 教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。