EEPW论坛

大家好，今天我们来聊聊协程的作用。

假设磁盘上有10个文件，你需要读取的内存，那么你该怎么用代码实现呢？

在接着往下看之前，先自己想一想这个问题，看看自己能想出几种方法，各自有什么样的优缺点。想清楚了吗（还在看吗），想清楚了我们继续往下看。

这可能是大多数同学都能想到的最简单方法，那就是一个一个的读取，读完一个接着读下一个。用代码表示是这样的：

for file in files:  result = file.read()  process(result)

1. 代码简单，容易理解

2. 可维护性好，这代码交给谁都能维护的了(论程序员的核心竞争力在哪里)

那么，慢的问题又该怎么解决呢？有的同学可能已经想到了，为啥要一个一个读取呢？并行读取不就可以加快速度了吗。

那么，该怎么并行读取文件呢？显然，地球人都知道，线程就是用来并行的。我们可以同时开启10个线程，每个线程中读取一个文件。用代码实现就是这样的：

def read_and_process(file):  result = file.read()  process(result)
def main():  files = [fileA，fileB，fileC......]  for file in files:     create_thread(read_and_process,                   file).run()  # 等待这些线程执行完成

1. 创建线程需要消耗系统资源，像内存等(想一想为什么？)

2. 调度开销，尤其是当线程数量较多且都比较繁忙时(同样想一想为什么？)

3. 创建多个线程不一定能加快I/O(如果此时设备处理能力已经饱和)

既然线程有这样那样的问题，那么还有没有更好的方法？答案是肯定的，并行编程不一定只能依赖线程这种技术。这里的答案就是基于事件驱动编程技术。

没错，即使在单个线程中，使用事件驱动+异步也可以实现IO并行处理，Node.js就是非常典型的例子。为什么单线程也可以做到并行呢？这是基于这样两个事实：

1. 相对于CPU的处理速度来说，IO是非常慢的

2. IO不怎么需要计算资源

因此，当我们发起IO操作后为什么要一直等着IO执行完成呢？在IO执行完之前的这段时间处理其它IO难道不香吗？这就是为什么单线程也可以并行处理多个IO的本质所在。回到我们的例子，该怎样用事件驱动+异步来改造上述程序呢？实际上非常简单。首先，我们需要创建一个event loop，这个非常简单：

event_loop = EventLoop()

def add_to_event_loop(event_loop, file):   file.asyn_read() # 文件异步读取   event_loop.add(file)

while event_loop:   file = event_loop.wait_one_IO_ready()   process(file.result)

 def add_to_event_loop(event_loop, file):   file.asyn_read() # 文件异步读取   event_loop.add(file)
def main():  files = [fileA，fileB，fileC ...]  event_loop = EventLoop()  for file in files:      add_to_event_loop(event_loop, file)   while event_loop:     file = event_loop.wait_one_IO_ready()     process(file.result)

接下来，我们看下程序执行的效果。在多线程情况下，假设有10个文件，每个文件读取需要1秒，那么很简单，并行读取10个文件需要1秒。那么，对于单线程+event loop呢？我们再次看下event loop + 异步版本的代码：

def add_to_event_loop(event_loop, file):   file.asyn_read() # 文件异步读取   event_loop.add(file)
def main():  files = [fileA，fileB，fileC......]  event_loop = EventLoop()  for file in files:      add_to_event_loop(event_loop, file)   while event_loop:     file = event_loop.wait_one_IO_ready()     process(file.result)

file = event_loop.wait_one_IO_ready()

for file in files:  add_to_event_loop(event_loop, file)

本质上，我们上述给出的event loop简单代码片段做的事情本质上和生物一样：给出刺激，做出反应。我们这里的给出event，然后处理event。这本质上就是所谓的Reactors模式。现在你应该明白所谓的Reactors模式是怎么一回事了吧！所谓的一些看上去复杂的异步框架，其核心不过就是这里给出的代码片段，只是这些框架可以支持更加复杂的多阶段任务处理，以及各种类型的IO。而我们这里给出的代码片段，只能处理文件读取这一类IO。

如果我们需要处理各种类型的IO上述代码片段会有什么问题吗？问题就在于上述代码片段就不会这么简单了，针对不同类型会有不同的处理方法。因此，上述process方法需要判断IO类型然后有针对性的处理，这会使得代码越来越复杂，越来越难以维护。幸好我们也有应对策略，那就是回调！我们可以把IO完成后的处理任务封装到回调函数中，然后和IO一并注册到event loop。就像这样：

def IO_type_1(event_loop, io):  io.start()   def callback(result):    process_IO_type_1(result)   event_loop.add((io, callback))

while event_loop:   io, callback = event_loop.wait_one_IO_ready()   callback(io.result)

虽然回调函数使得event loop内部更加简洁，但依然有其它问题，让我们来仔细看看回调函数：

def start_IO_type_1(event_loop, io):  io.start()   def callback(result):    process_IO_type_1(result)   event_loop.add((io, callback))

1. 发起IO

2. IO处理

其中，第2部分放到了回调函数中，这样的异步处理天然不容易理解，这和我们熟悉的发起IO，等待IO完成、处理IO结果的同步模块有很大差别。这里的给的例子很简单，所以你可能不以为意，但是当处理的任务非常复杂时，可能会出现回调函数中嵌套回调函数，也就是回调地狱，这样的代码维护起来会让你怀疑为什么要称为一名苦逼的码农。

让我们再来仔细的看看问题出在了哪里？同步编程模式下很简单，但是同步模式下发起IO，线程会被阻塞，这样我们就不得不创建多个线程，但是创建过多线程又会有性能问题。这样为了发起IO后不阻塞当前线程我们就不得不采用异步编程+event loop。在这种模式下，异步发起IO不会阻塞调用线程，我们可以使用单线程加异步编程的方法来实现多线程效果，但是在这种模式下处理一个IO的流程又不得不被拆分成两部分，这样的代码违反程序员直觉，因此难以维护。那么很自然的，有没有一种方法既能有同步编程的简单理解又会有异步编程的非阻塞呢？答案是肯定的，这就是协程。

利用协程，我可以以同步的形式来异步编程。这是什么意思呢？我们之所以采用异步编程是为了发起IO后不阻塞当前线程，而是用协程，程序员可以自行决定在什么时刻挂起当前协程，这样也不会阻塞当前线程。而协程最棒的一点就在于挂起后可以暂存执行状态，恢复运行后可以在挂起点继续运行，这样我们就不再需要像回调那样将一个IO的处理流程拆分成两部分了。因此，我们可以在发起异步IO，这样不会阻塞当前线程，同时在发起异步IO后挂起当前协程，当IO完成后恢复该协程的运行。这样一来，我们就可以实现同步的方式来异步编程了。接下来，我们就用协程来改造一下回调版本的IO处理方式：

def start_IO_type_1(io):  io.start() # IO异步请求  yield      # 暂停当前协程   process_IO_type_1(result) # 处理返回结果

def add_to_event_loop(io, event_loop):  coroutine = start_IO_type_1(io)  next(coroutine)  event_loop.add(coroutine)

while event_loop:   coroutine = event_loop.wait_one_IO_ready()   next(coroutine)

看上去简简单单的IO，实际上一点都不简单。为了高效进行IO操作，我们采用的技术是这样演进的：

1. 单线程串行 + 阻塞式IO(同步)

2. 多线程并行 + 阻塞式IO(并行)

3. 单线程 + 非阻塞式IO(异步) + event loop

4. 单线程 + 非阻塞式IO(异步) + event loop + 回调

5. Reactor模式(更好的单线程 + 非阻塞式IO+ event loop + 回调)

6. 单线程 + 非阻塞式IO(异步) + event loop + 协程

最终，我们采用协程技术获取到了异步编程的高效以及同步编程的简单理解，这也是当今高性能服务器常用的一种技术组合。

希望这篇文章能对你理解高效IO有所帮助。