python实现高并发_Python也能高并发

【小宅按】并发&＃xff0c;在操作系统中&＃xff0c;是指一个时间段中有几个程序都处于已启动运行到运行完毕之间&＃xff0c;且这几个程序都是在同一个处理机上运行&＃xff0c;但任一个时刻点上只有一个程序在处理机上运行。

里面的一个时间段内说明非常重要,这里假设这个时间段是一秒&＃xff0c;所以本文指的并发是指服务器在一秒中处理的请求数量&＃xff0c;即rps&＃xff0c;那么rps高,本文就认为高并发。

操作系统到底在干啥?

如果由笔者来概括&＃xff0c;操作系统大概做了两件事情&＃xff0c;计算与IO&＃xff0c;任何具体数学计算或者逻辑判断&＃xff0c;或者业务逻辑都是计算&＃xff0c;而网络交互&＃xff0c;磁盘交互&＃xff0c;人机之间的交互都是IO。

高并发的瓶颈在哪?

根据笔者经验&＃xff0c;大多数时候在IO上面。注意&＃xff0c;这里说得是大多数&＃xff0c;不是说绝对。

因为大多数时候业务本质上都是从数据库或者其他存储上读取内容&＃xff0c;然后根据一定的逻辑&＃xff0c;将数据返回给用户&＃xff0c;比如大多数web内容。而大多数逻辑的交互都算不上计算量多大的逻辑&＃xff0c;CPU的速度要远远高于内存IO,磁盘IO,网络IO, 而这些IO中网络IO最慢。

在根据上面的笔者对操作系统的概述&＃xff0c;当并发高到一定的程度&＃xff0c;根据业务的不同&＃xff0c;比如计算密集&＃xff0c;IO密集&＃xff0c;或两者皆有&＃xff0c;因此瓶颈可能出在计算上面或者IO上面&＃xff0c;又或两者兼有。

而本文解决的高并发&＃xff0c;是指IO密集的高并发瓶颈&＃xff0c;因此&＃xff0c;计算密集的高并发并不在本文的讨论范围内。

为了使本文歧义更少&＃xff0c;这里的IO主要指网络IO.

Python怎么处理高并发&＃xff1f;

使用协程, 事件循环, 高效IO模型(比如多路复用&＃xff0c;比如epoll), 三者缺一不可。

很多时候&＃xff0c;笔者看过的文章都是说协程如何如何&＃xff0c;最后告诉我一些协程库或者asyncio用来说明协程的威力&＃xff0c;最终我看懂了协程&＃xff0c;却还是不知道它为啥能高并发&＃xff0c;这也是笔者写本文的目的。

但是一切还是得从生成器说起&＃xff0c;因为asyncio或者大多数协程库内部也是通过生成器实现的。

注意上面的三者缺一不可。

如果只懂其中一个&＃xff0c;那么你懂了三分之一&＃xff0c;以此类推&＃xff0c;只有都会了&＃xff0c;你才知道为啥协程能高并发。

生成器

生成器的定义很抽象&＃xff0c;现在不懂没关系&＃xff0c;但是当你懂了之后回过头再看&＃xff0c;会觉得定义的没错&＃xff0c;并且准确。下面是定义摘自百度百科: 生成器是一次生成一个值的特殊类型函数。可以将其视为可恢复函数。

关于生成器的内容&＃xff0c;本文着重于生成器实现了哪些功能&＃xff0c;而不是生成器的原理及内部实现。

yield

简单例子如下

def gen_func():

yield 1

yield 2

yield 3

if __name__ &＃61;&＃61; &＃39;__main__&＃39;:

gen &＃61; gen_func()

for i in gen:

print(i)

output:

1

2

3

上面的例子没有什么稀奇的不是吗&＃xff1f;yield像一个特殊的关键字&＃xff0c;将函数变成了一个类似于迭代器的对象&＃xff0c;可以使用for循环取值。

send, next

协程自然不会这么简单&＃xff0c;python协程的目标是星辰大海&＃xff0c;从上面的例之所以get不到它的野心&＃xff0c;是因为你没有试过send, next两个函数。

首先说next

def gen_func():

yield 1

yield 2

yield 3

if __name__ &＃61;&＃61; &＃39;__main__&＃39;:

gen &＃61; gen_func()

print(next(gen))

print(next(gen))

print(next(gen))

output:

1

2

3

next的操作有点像for循环&＃xff0c;每调用一次next&＃xff0c;就会从中取出一个yield出来的值&＃xff0c;其实还是没啥特别的&＃xff0c;感觉还没有for循环好用。

不过&＃xff0c;不知道你有没有想过&＃xff0c;如果你只需要一个值&＃xff0c;你next一次就可以了&＃xff0c;然后你可以去做其他事情&＃xff0c;等到需要的时候才回来再次next取值。

就这一部分而言&＃xff0c;你也许知道为啥说生成器是可以暂停的了&＃xff0c;不过&＃xff0c;这似乎也没什么用&＃xff0c;那是因为你不知到时&＃xff0c;生成器除了可以抛出值&＃xff0c;还能将值传递进去。

接下来我们看send的例子。

def gen_func():

a &＃61; yield 1

print("a: ", a)

b &＃61; yield 2

print("b: ", b)

c &＃61; yield 3

print("c: ", c)

return "finish"

if __name__ &＃61;&＃61; &＃39;__main__&＃39;:

gen &＃61; gen_func()

for i in range(4):

if i &＃61;&＃61; 0:

print(gen.send(None))

else:

# 因为gen生成器里面只有三个yield&＃xff0c;那么只能循环三次。

# 第四次循环的时候,生成器会抛出StopIteration异常,并且return语句里面内容放在StopIteration异常里面

try:

print(gen.send(i))

except StopIteration as e:

print("e: ", e)

output:

1

a: 1

2

b: 2

3

c: 3

e: finish

send有着next差不多的功能&＃xff0c;不过send在传递一个值给生成器的同时&＃xff0c;还能获取到生成器yield抛出的值&＃xff0c;在上面的代码中&＃xff0c;send分别将None,1,2,3四个值传递给了生成器&＃xff0c;之所以第一需要传递None给生成器&＃xff0c;是因为规定&＃xff0c;之所以规定&＃xff0c;因为第一次传递过去的值没有特定的变量或者说对象能接收&＃xff0c;所以规定只能传递None, 如果你传递一个非None的值进去&＃xff0c;会抛出一下错误

TypeError: can&＃39;t send non-None value to a just-started generator

从上面的例子我们也发现&＃xff0c;生成器里面的变量a,b,c获得了&＃xff0c;send函数发送将来的1, 2, 3.如果你有事件循环或者说多路复用的经验&＃xff0c;你也许能够隐隐察觉到微妙的感觉。

这个微妙的感觉是&＃xff0c;是否可以将IO操作yield出来&＃xff1f;由事件循环调度, 如果你能get到这个微妙的感觉,那么你已经知道协程高并发的秘密了.

但是还差一点点.嗯, 还差一点点了.

yield from

下面是yield from的例子

def gen_func():

a &＃61; yield 1

print("a: ", a)

b &＃61; yield 2

print("b: ", b)

c &＃61; yield 3

print("c: ", c)

return 4

def middle():

gen &＃61; gen_func()

ret &＃61; yield from gen

print("ret: ", ret)

return "middle Exception"

def main():

mid &＃61; middle()

for i in range(4):

if i &＃61;&＃61; 0:

print(mid.send(None))

else:

try:

print(mid.send(i))

except StopIteration as e:

print("e: ", e)

if __name__ &＃61;&＃61; &＃39;__main__&＃39;:

main()

output:

1

a: 1

2

b: 2

3

c: 3

ret: 4

e: middle Exception

从上面的代码我们发现,main函数调用的middle函数的send,但是gen_func函数却能接收到main函数传递的值.有一种透传的感觉,这就是yield from的作用, 这很关键。

而yield from最终传递出来的值是StopIteration异常&＃xff0c;异常里面的内容是最终接收生成器(本示例是gen_func)return出来的值&＃xff0c;所以ret获得了gen_func函数return的4.但是ret将异常里面的值取出之后会继续将接收到的异常往上抛&＃xff0c;所以main函数里面需要使用try语句捕获异常。而gen_func抛出的异常里面的值已经被middle函数接收&＃xff0c;所以middle函数会将抛出的异常里面的值设为自身return的值&＃xff0c;

至此生成器的全部内容讲解完毕&＃xff0c;如果&＃xff0c;你get到了这些功能&＃xff0c;那么你已经会使用生成器了。

小结

再次强调,本小结只是说明生成器的功能,至于具体生成器内部怎么实现的,你可以去看其他文章,或者阅读源代码.

io模型

Linux平台一共有五大IO模型&＃xff0c;每个模型有自己的优点与确定。根据应用场景的不同可以使用不同的IO模型。

不过本文主要的考虑场景是高并发&＃xff0c;所以会针对高并发的场景做出评价。

同步IO

同步模型自然是效率最低的模型了&＃xff0c;每次只能处理完一个连接才能处理下一个,如果只有一个线程的话, 如果有一个连接一直占用&＃xff0c;那么后来者只能傻傻的等了。所以不适合高并发&＃xff0c;不过最简单&＃xff0c;符合惯性思维。

非阻塞式IO

不会阻塞后面的代码&＃xff0c;但是需要不停的显式询问内核数据是否准备好&＃xff0c;一般通过while循环&＃xff0c;而while循环会耗费大量的CPU。所以也不适合高并发。

多路复用

当前最流行&＃xff0c;使用最广泛的高并发方案。而多路复用又有三种实现方式, 分别是select, poll, epoll。

select, poll, epoll

select,poll由于设计的问题&＃xff0c;当处理连接过多会造成性能线性下降&＃xff0c;而epoll是在前人的经验上做过改进的解决方案。不会有此问题。

不过select, poll并不是一无是处&＃xff0c;假设场景是连接数不多&＃xff0c;并且每个连接非常活跃&＃xff0c;select&＃xff0c;poll是要性能高于epoll的。

至于为啥&＃xff0c;查看小结参考链接, 或者自行查询资料。但是本文讲解的高并发可是指的连接数非常多的。

信号驱动式IO

很偏门的一个IO模型&＃xff0c;不曾遇见过使用案例。看模型也不见得比多路复用好用。

异步非阻塞IO

用得不是很多&＃xff0c;理论上比多路复用更快&＃xff0c;因为少了一次调用&＃xff0c;但是实际使用并没有比多路复用快非常多&＃xff0c;所以为啥不使用广泛使用的多路复用。

小结

使用最广泛多路复用epoll, 可以使得IO操作更有效率。但是使用上有一定的难度。

至此&＃xff0c;如果你理解了多路复用的IO模型&＃xff0c;那么你了解python为什么能够通过协程实现高并发的三分之二了。

事件循环

上面的IO模型能够解决IO的效率问题&＃xff0c;但是实际使用起来需要一个事件循环驱动协程去处理IO。

简单实现

下面引用官方的一个简单例子。

import selectors

import socket

# 创建一个selctor对象

# 在不同的平台会使用不同的IO模型,比如Linux使用epoll, windows使用select(不确定)

# 使用select调度IO

sel &＃61; selectors.DefaultSelector()

# 回调函数,用于接收新连接

def accept(sock, mask):

conn, addr &＃61; sock.accept() # Should be ready

print(&＃39;accepted&＃39;, conn, &＃39;from&＃39;, addr)

conn.setblocking(False)

sel.register(conn, selectors.EVENT_READ, read)

# 回调函数,用户读取client用户数据

def read(conn, mask):

data &＃61; conn.recv(1000) # Should be ready

if data:

print(&＃39;echoing&＃39;, repr(data), &＃39;to&＃39;, conn)

conn.send(data) # Hope it won&＃39;t block

else:

print(&＃39;closing&＃39;, conn)

sel.unregister(conn)

conn.close()

# 创建一个非堵塞的socket

sock &＃61; socket.socket()

sock.bind((&＃39;localhost&＃39;, 1234))

sock.listen(100)

sock.setblocking(False)

sel.register(sock, selectors.EVENT_READ, accept)

# 一个事件循环,用于IO调度

# 当IO可读或者可写的时候, 执行事件所对应的回调函数

def loop():

while True:

events &＃61; sel.select()

for key, mask in events:

callback &＃61; key.data

callback(key.fileobj, mask)

if __name__ &＃61;&＃61; &＃39;__main__&＃39;:

loop()

上面代码中loop函数对应事件循环,它要做的就是一遍一遍的等待IO,然后调用事件的回调函数.

但是作为事件循环远远不够,比如怎么停止,怎么在事件循环中加入其他逻辑.

小结

如果就功能而言,上面的代码似乎已经完成了高并发的影子,但是如你所见,直接使用select的编码难度比较大, 再者回调函数素来有"回调地狱"的恶名.

实际生活中的问题要复杂的多&＃xff0c;作为一个调库狂魔&＃xff0c;怎么可能会自己去实现这些&＃xff0c;所以python官方实现了一个跨平台的事件循环&＃xff0c;至于IO模型具体选择&＃xff0c;官方会做适配处理。

不过官方实现是在Python3.5及以后了&＃xff0c;3.5之前的版本只能使用第三方实现的高并发异步IO解决方案, 比如tornado,gevent,twisted。

至此你需要get到python高并发的必要条件了.

asyncio

在本文开头,笔者就说过,python要完成高并发需要协程,事件循环,高效IO模型.而Python自带的asyncio模块已经全部完成了.尽情使用吧.

下面是有引用官方的一个例子

import asyncio

# 通过async声明一个协程

async def handle_echo(reader, writer):

# 将需要io的函数使用await等待, 那么此函数就会停止

# 当IO操作完成会唤醒这个协程

# 可以将await理解为yield from

data &＃61; await reader.read(100)

message &＃61; data.decode()

addr &＃61; writer.get_extra_info(&＃39;peername&＃39;)

print("Received %r from %r" % (message, addr))

print("Send: %r" % message)

writer.write(data)

await writer.drain()

print("Close the client socket")

writer.close()

# 创建事件循环

loop &＃61; asyncio.get_event_loop()

# 通过asyncio.start_server方法创建一个协程

coro &＃61; asyncio.start_server(handle_echo, &＃39;127.0.0.1&＃39;, 8888, loop&＃61;loop)

server &＃61; loop.run_until_complete(coro)

# Serve requests until Ctrl&＃43;C is pressed

print(&＃39;Serving on {}&＃39;.format(server.sockets[0].getsockname()))

try:

loop.run_forever()

except KeyboardInterrupt:

pass

# Close the server

server.close()

loop.run_until_complete(server.wait_closed())

loop.close()

总的来说python3.5明确了什么是协程&＃xff0c;什么是生成器&＃xff0c;虽然原理差不多&＃xff0c;但是这样会使得不会让生成器即可以作为生成器使用(比如迭代数据)又可以作为协程。

所以引入了async,await使得协程的语义更加明确。

asyncio生态

asyncio官方只实现了比较底层的协议&＃xff0c;比如TCP&＃xff0c;UDP。所以诸如HTTP协议之类都需要借助第三方库&＃xff0c;比如aiohttp。

虽然异步编程的生态不够同步编程的生态那么强大&＃xff0c;但是如果又高并发的需求不妨试试&＃xff0c;下面说一下比较成熟的异步库

aiohttp

异步http client/server框架

sanic

速度更快的类flask web框架。

uvloop

快速&＃xff0c;内嵌于asyncio事件循环的库&＃xff0c;使用cython基于libuv实现。

官方性能测试:

nodejs的两倍&＃xff0c;追平golang为了减少歧义&＃xff0c;这里的性能测试应该只是网络IO高并发方面不是说任何方面追平golang。

总结

Python之所以能够处理网络IO高并发&＃xff0c;是因为借助了高效的IO模型&＃xff0c;能够最大限度的调度IO&＃xff0c;然后事件循环使用协程处理IO&＃xff0c;协程遇到IO操作就将控制权抛出&＃xff0c;那么在IO准备好之前的这段事件&＃xff0c;事件循环就可以使用其他的协程处理其他事情&＃xff0c;然后协程在用户空间&＃xff0c;并且是单线程的&＃xff0c;所以不会像多线程&＃xff0c;多进程那样频繁的上下文切换&＃xff0c;因而能够节省大量的不必要性能损失。注: 不要再协程里面使用time.sleep之类的同步操作&＃xff0c;因为协程再单线程里面&＃xff0c;所以会使得整个线程停下来等待&＃xff0c;也就没有协程的优势了

本文主要讲解Python为什么能够处理高并发,不是为了讲解某个库怎么使用,所以使用细节请查阅官方文档或者执行。

无论什么编程语言&＃xff0c;高性能框架&＃xff0c;一般由事件循环 &＃43; 高性能IO模型(也许是epoll)组成。

更多精彩内容&＃xff0c;请滑至顶部点击右上角关注小宅哦~

来源&＃xff1a;51CTO博客 youerning