Python协程原理解析与gevent实战指南

云舒

发布时间：2026-10-13| 3人浏览过

原创

本文深入解析Python中协程（Coroutine）的概念、与线程的区别及其在IO密集型场景下的优势。通过yield生成器、greenlet库及gevent库的代码示例，展示协程从基础实现到自动切换IO操作的演进过程。重点讲解gevent如何通过猴子补丁实现非阻塞IO，并包含高并发TCP服务器的完整实现逻辑，帮助开发者理解并应用协程提升程序性能。

本文主要探讨Python语言中协程（Coroutine）的相关技术细节，具体展开如下内容。

Num01–>协程的定义

协程，也被称为微线程或纤程，其英文名为Coroutine。

首先需要明确协程的本质：它是一种比线程更小的执行单元。之所以称其为执行单元，是因为它自带CPU上下文。这意味着在合适的时机，程序可以将一个协程切换到另一个协程。只要在此过程中正确保存或恢复CPU上下文，程序即可继续运行。

Num02–>协程和线程的差异

乍看之下，协程切换与线程切换相似，但二者有本质区别。线程切换涉及操作系统层面的复杂操作，不仅包括保存和恢复CPU上下文，还涉及操作系统为每个线程分配的缓存（Cache）等数据的恢复操作，因此线程切换非常消耗性能。相比之下，协程切换仅涉及CPU上下文的单纯操作，系统每秒可处理上百万次切换而毫无压力。

Num03–>协程带来的问题

协程存在一个关键问题：操作系统无法感知协程的存在，因此不会自动协助进行切换。那么，谁来负责切换？核心问题在于如何让需要执行的协程获得更多CPU时间。

以下举例说明：

目前的协程框架通常采用1:N模式，即一个线程作为容器容纳多个协程。那么由谁来适时切换这些协程？答案是由协程自身主动让出CPU。每个协程池中包含一个调度器，该调度器是被动调度的，不会主动发起调度。当一个协程发现执行受阻（例如异步等待网络数据返回，但当前数据尚未到达），该协程会通知调度器。此时执行流转到调度器代码，调度器根据预设的调度算法找到当前最急需CPU资源的协程，切换其CPU上下文并将运行权交给该协程。直到该协程再次遇到执行阻塞需要等待，或主动调用让出CPU的API，才会触发下一次调度。

Num04–>协程的好处

在IO密集型程序中，由于IO操作速度远慢于CPU操作，CPU往往需要等待IO完成。在同步IO模式下，系统必须切换线程，以便操作系统在IO等待期间执行其他任务。虽然这种代码符合人类的线性思维习惯，但大量的线程切换带来了显著的性能浪费，尤其是在IO密集型的程序中。

为此，人们发明了异步IO，即当数据到达时触发回调，以减少线程切换带来的性能损失。然而，这种方式的缺点也很明显：操作被“分片”了，代码不再“一气呵成”，而是每次接收数据时都要判断数据是否足够处理，若不足则继续等待。这种写法可读性极低，且不符合人类的思维习惯。

协程能很好地解决这一问题。例如，将一个IO操作封装为一个协程，当触发IO操作时，自动让出CPU给其他协程。由于协程切换非常轻量，这种对异步IO的封装既保留了高性能，又保证了代码的易编写性和可读性。这在高IO密集型程序中表现优异，但在高CPU密集型程序中则优势不明显。

Num05–>yield实现一个简单协程案例

import time
def A():
  while True:
    print("----我是A函数---")
    yield
    time.sleep(0.5)
def B(c):
  while True:
    print("----我是B函数---")
    next(c)
    time.sleep(0.5)
if __name__ == '__main__':
  a = A()
  B(a)

# 结果如下：
# ----我是B函数---
# ----我是A函数---
# ----我是B函数---
# ----我是A函数---
# ----我是B函数---
# ----我是A函数---
# ----我是B函数---
# ----我是A函数---
# ----我是B函数---
# ----我是A函数---
# ......

Num06–>greenlet版本实现协程案例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : xiaoke
from greenlet import greenlet
import time


def test1():
  while True:
    print("---我是A函数--")
    gr2.switch()
    time.sleep(0.5)


def test2():
  while True:
    print("---我是B函数--")
    gr1.switch()
    time.sleep(0.5)


def main():
  # 切换到gr1中运行
  gr1.switch()


if __name__ == '__main__':
  gr1 = greenlet(test1)
  gr2 = greenlet(test2)
  main()

# 结果如下：
# ---我是A函数--
# ---我是B函数--
# ---我是A函数--
# ---我是B函数--
# ---我是A函数--
# ---我是B函数--
# ---我是A函数--
# ---我是B函数--
# ......

Num07–>gevent实现协程案例

其原理是：当一个greenlet遇到IO操作（如网络访问、文件读写等）时，例如发起网络请求，它会自动切换到其他greenlet；等到IO操作完成，系统会在适当的时候将其切换回来继续执行。

由于IO操作非常耗时，经常使程序处于等待状态。有了gevent为我们自动切换协程，就能保证总有greenlet在运行，而不是让程序陷入等待IO的空闲状态。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : xiaoke
import gevent


def task1(n):
  for i in range(n):
    print('----task1-----')

    gevent.sleep(1)
    # time.sleep(1) # time.sleep没有让gevent感知到等待


def task2(n):
  for i in range(n):
    print('----task2-----')

    gevent.sleep(1)
    # time.sleep(1)


def main():
  g1 = gevent.spawn(task1, 5)
  g2 = gevent.spawn(task2, 5)

  g1.join()
  g2.join()


if __name__ == "__main__":
  main()


# 结果如下：
# ----task1-----
# ----task2-----
# ----task1-----
# ----task2-----
# ----task1-----
# ----task2-----
# ----task1-----
# ----task2-----
# ----task1-----
# ----task2-----

gevent并发下载器

在实际代码中，我们通常不会使用gevent.sleep()来手动切换协程，而是在执行到IO操作时，由gevent自动完成切换。具体代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : xiaoke

import urllib.request # py3

import gevent
from gevent import monkey
# 猴子补丁，将标准库的涉及IO操作方法替换成gevent
monkey.patch_all() 

# 协程的任务函数
def my_download(url):
  print('GET %s' % url)

  response = urllib.request.urlopen(url)
  data = response.read()

  print('下载 %d bytes from %s' % (len(data), url))


def main():
  g1 = gevent.spawn(my_download, 'http://www.google.cn')
  g2 = gevent.spawn(my_download, 'http://www.qq.com')
  g3 = gevent.spawn(my_download, 'http://www.baidu.com')

  gevent.joinall([g1, g2, g3]) # 等待指定的协程结束


if __name__ == "__main__":
  main()

# 结果如下：
# GET http://www.google.cn
# GET http://www.qq.com
# GET http://www.baidu.com
# 下载 102221 bytes from http://www.baidu.com
# 下载 52297 bytes from http://www.qq.com
# 下载 3213 bytes from http://www.google.cn

#从上能够看到是先获取baidu的相关信息，然后依次是qq
#google，但是收到数据的先后顺序不一定与发送顺序相同，
#这也就体现出了异步，即不确定什么时候会收到数据，顺序不一定.

Num08–>gevent版–TCP服务器

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : xiaoke
import socket
import gevent
from gevent import monkey
#猴子补丁，将标准库的涉及IO操作方法替换成gevent
monkey.patch_all()


# 需要为客户端提供服务
def do_service(connect_socket):
  while True:
    # tcp recv() 只会返回接收到的数据
    recv_data = connect_socket.recv(1024)

    # if recv_data == b'':
    if len(recv_data) == 0:
      # 发送方关闭tcp的连接,recv()不会阻塞，而是直接返回''
      # print('client %s close' % str(client_addr))
      # s.getpeername()  s.getsockname()
      print('client %s close' % str(connect_socket.getpeername()))
      break
    print('recv: %s' % recv_data.decode('gbk'))

def main():

  listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  # 设置允许复用地址,当建立连接之后服务器先关闭，设置地址复用
  listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

  my_addr = ('192.168.105.125', 8080)
  listen_socket.bind(my_addr)

  listen_socket.listen(5) # 设置套接字成监听,5表示一个己连接队列长度
  print('listening...')

  while True:
    # 接受连接请求，创建连接套接字，用于客户端连通信
    connect_socket, client_addr = listen_socket.accept() # accept默认会引起阻塞
    # 新创建连接用的socket, 客户端的地址
    # print(connect_socket)
    print(client_addr)

    # 每当来新的客户端连接，创建协程，由协程和客户端通信
    coroutine_do_service = gevent.spawn(do_service, connect_socket)


if __name__ == "__main__":
  main()