Python(3)—从迭代器到异步IO

澳门新葡亰网址 7

Iterator 接口

interface Iterator extends Traversable
{
    // 获取当前内部标量指向的元素的数据
    public mixed current()
    // 获取当前标量
    public scalar key()
    // 移动到下一个标量
    public void next()
    // 重置标量
    public void rewind()
    // 检查当前标量是否有效
    public boolean valid()
}

3 协程

迭代器实现 xrange 函数

来看看迭代实现的 range,我们叫做 xrange,他实现了 Iterator 接口必须的
5 个方法:

class Xrange implements Iterator
{
    protected $start;
    protected $limit;
    protected $step;
    protected $current;
    public function __construct($start, $limit, $step = 1)
    {
        $this->start = $start;
        $this->limit = $limit;
        $this->step  = $step;
    }
    public function rewind()
    {
        $this->current = $this->start;
    }
    public function next()
    {
        $this->current += $this->step;
    }
    public function current()
    {
        return $this->current;
    }
    public function key()
    {
        return $this->current + 1;
    }
    public function valid()
    {
        return $this->current <= $this->limit;
    }
}

使用时代码如下:

foreach (new Xrange(0, 9) as $key => $val) {
    echo $key, ' ', $val, "n";
}

输出:

0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9

看上去功能和 range() 函数所做的一致,不同点在于迭代的是一个 对象(Object) 而不是数组:

var_dump(new Xrange(0, 9));

输出:

object(Xrange)#1 (4) {
  ["start":protected]=>
  int(0)
  ["limit":protected]=>
  int(9)
  ["step":protected]=>
  int(1)
  ["current":protected]=>
  NULL
}

另外,内存的占用情况也完全不同:

// range
$startMemory = memory_get_usage();
$arr = range(0, 500000);
echo 'range(): ', memory_get_usage() - $startMemory, " bytesn";
unset($arr);
// xrange
$startMemory = memory_get_usage();
$arr = new Xrange(0, 500000);
echo 'xrange(): ', memory_get_usage() - $startMemory, " bytesn";

输出:

xrange(): 624 bytes
range(): 72194784 bytes

range() 函数在执行后占用了 50W
个元素内存空间,而 xrange 对象在整个迭代过程中只占用一个对象的内存。

3.1 概念理解

线程与进程,有自己的上下文,调度是由CPU来决定调度的;而协程也相对独立,有自己的上下文,但是其切换由自己控制,由当前协程切换到其他协程由当前协程来控制(程序员控制),其实就是在一个线程中切换子线程。
  相比多线程有如下好处:一是协程极高的执行效率。因为子程序切换不是线程切换,而是由程序自身控制,因此,没有线程切换的开销,当线程数量越多,协程的性能优势就越明显。二是不需要多线程的锁机制,因为只有一个线程,也不存在同时写变量冲突,在协程中控制共享资源不加锁,只需要判断状态就好了,所以执行效率比多线程高很多。
  协程、线程、进程在不同场景下的适用性不尽相同,在其他语言中,协程的其实是意义不大的多线程即可已解决I/O的问题,但是在python因为有GIL(Global
Interpreter Lock 全局解释器锁
)在同一时间只有一个线程在工作,所以如果一个线程里面I/O操作特别多,协程就比较适用,如网络请求。

并行和并发

谈到多进程以及类似同时执行多个任务的模型,就不得不先谈谈并行和并发。

1. 迭代(iteration)与迭代器(iterator)
  1.1 构建简单迭代器
  1.2 调用next()
  1.3 迭代器状态图
2. 生成器(generator)
  2.1 创建简单生成器
  2.2 利用函数定义生成器
3. 协程
  3.1 概念理解
  3.2 实例
4. 异步IO
  4.1 概念理解
  4.2 实例

单任务改造

如果想将一个单进程任务改造成并发执行,我们可以选择改造成多进程或者协程:

  • 多进程,不改变任务执行的整体过程,在一个时间段内同时执行多个相同的代码段,调度权在
    CPU,如果一个任务能独占一个 CPU 则可以实现并行。
  • 协程,把原有任务拆分成多个小任务,原有任务的执行流程被改变,调度权在进程自己,如果有
    IO 并且可以实现异步,则可以实现并行。

多进程改造

澳门新葡亰网址 1

协程改造

澳门新葡亰网址 2

3.2 实例

Python中的协程是通过“生成器(generator)”的概念实现的。这里引用廖雪峰Python教程中的例子,并将其修改为定外卖场景:

def shop():
    '''定义商家(生成器)
    '''        
    print("[-商家-] 开始接单 ......")
    print("###############################")
    r = "商家第1次接单完成"       # 初始化返回结果,并在启动商家时,返回给消费者
    while True:    
        n = yield r  # (n = yield):商家通过yield接收消费者的消息,(yield r):返给结果  
        print("[-商家-] 正在处理第%s次订单 ......" % n)
        print("[-商家-] 第%s次订单正在配送中 ......" % n)
        print("[-商家-] 第%s次订单已送达" % n)
        r = "商家第%s次接单完成" % (n+1)     # 商家信息,下个循环返回给消费者

def consumer(g):  
    '''定义消费者
    @g:商家生成器
    '''       
    print("[消费者] 开始下单 ......")
    r = g.send(None)    # 启动商家生成器  
    n = 0
    while n < 5:
        n += 1
        print("[消费者] 已下第%s单" % n)
        print("[消费者] 接受商家消息:%s" % r)
        r = g.send(n)   # 向商家发送下单消息并准备接收结果。此时会切换到消费者执行
        print("###############################")
    g.close()           # 关闭商家生成器
    print("[消费者] 停止接单 ......")

if __name__ == "__main__":
    g = shop() 
    consumer(g)

[消费者] 开始下单 ......
[-商家-] 开始接单 ......
###############################
[消费者] 已下第1单
[消费者] 接受商家消息:商家第1次接单完成
[-商家-] 正在处理第1次订单 ......
[-商家-] 第1次订单正在配送中 ......
[-商家-] 第1次订单已送达
###############################
[消费者] 已下第2单
[消费者] 接受商家消息:商家第2次接单完成
[-商家-] 正在处理第2次订单 ......
[-商家-] 第2次订单正在配送中 ......
[-商家-] 第2次订单已送达
###############################
[消费者] 已下第3单
[消费者] 接受商家消息:商家第3次接单完成
[-商家-] 正在处理第3次订单 ......
[-商家-] 第3次订单正在配送中 ......
[-商家-] 第3次订单已送达
###############################
[消费者] 已下第4单
[消费者] 接受商家消息:商家第4次接单完成
[-商家-] 正在处理第4次订单 ......
[-商家-] 第4次订单正在配送中 ......
[-商家-] 第4次订单已送达
###############################
[消费者] 已下第5单
[消费者] 接受商家消息:商家第5次接单完成
[-商家-] 正在处理第5次订单 ......
[-商家-] 第5次订单正在配送中 ......
[-商家-] 第5次订单已送达
###############################
[消费者] 停止接单 ......

生成器实现 xrange 函数

function xrange($start, $limit, $step = 1) {
    for ($i = 0; $i < $limit; $i += $step) { 
        yield $i + 1 => $i;
    }
}
foreach (xrange(0, 9) as $key => $val) {
    printf("%d %d n", $key, $val);
}
// 输出
// 1 0
// 2 1
// 3 2
// 4 3
// 5 4
// 6 5
// 7 6
// 8 7
// 9 8

实际上生成器生成的正是一个迭代器对象实例,该迭代器对象继承了 Iterator 接口,同时也包含了生成器对象自有的接口,具体可以参考 Generator 类的定义以及语法参考。

同时需要注意的是:

一个生成器不可以返回值,这样做会产生一个编译错误。然而 return
空是一个有效的语法并且它将会终止生成器继续执行。

4.2 实例

只有协程还不够,还不足以实现异步IO,我们必须实现消息循环和状态的控制,在此我们先了解一下几个关键词。

  • asyncio
    Python
    3.4版本引入的标准库,直接内置了对异步IO的支持。asyncio的编程模型就是一个消息循环。我们从asyncio模块中直接获取一个EventLoop的引用,然后把需要执行的协程扔到EventLoop中执行,就实现了异步IO。

  • async/await
    python3.5中新加入的特性, 将异步从原来的yield
    写法中解放出来,变得更加直观。其中async修饰的函数为异步函数,await
    替换了yield from, 表示这一步为异步操作。

  • aiohttp
    一个提供异步web服务的库,分为服务器端和客户端。这里主要使用其客户端。

import asyncio
import aiohttp
async def get(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            print(url, resp.status)
            print(url, await resp.text())

loop = asyncio.get_event_loop()     # 得到一个事件循环模型
urls = ["https://movie.douban.com/tag/科幻?start="+str(1)+"&type=T" for i in range(1,4)]
tasks = [ get(url) for url in urls] # 初始化任务列表

loop.run_until_complete(asyncio.wait(tasks))    # 执行任务
loop.close()                        # 关闭事件循环列表

参考与拓展阅读:
[1]Python生成器详解 |
投稿

[2]廖雪峰Python教程
[3]Python学习:异步IO:协程和asyncio
[4]Python【第十篇】协程、异步IO
[5]Python进阶:理解Python中的异步IO和协程(Coroutine),并应用在爬虫中
[6]异步爬虫: async/await 与
aiohttp的使用,以及例子

[7]Python
异步网络爬虫(1)


个人Github
个人博客whenif
欢迎各路同学互相交流

多进程/线程

最早的服务器端程序都是通过多进程、多线程来解决并发IO的问题。进程模型出现的最早,从Unix
系统诞生就开始有了进程的概念。最早的服务器端程序一般都是 Accept
一个客户端连接就创建一个进程,然后子进程进入循环同步阻塞地与客户端连接进行交互,收发处理数据。

多线程模式出现要晚一些,线程与进程相比更轻量,而且线程之间共享内存堆栈,所以不同的线程之间交互非常容易实现。比如实现一个聊天室,客户端连接之间可以交互,聊天室中的玩家可以任意的其他人发消息。用多线程模式实现非常简单,线程中可以直接向某一个客户端连接发送数据。而多进程模式就要用到管道、消息队列、共享内存等等统称进程间通信(IPC)复杂的技术才能实现。

最简单的多进程服务端模型

$serv = stream_socket_server("tcp://0.0.0.0:8000", $errno, $errstr) 
or die("Create server failed");
while(1) {
    $conn = stream_socket_accept($serv);
    if (pcntl_fork() == 0) {
        $request = fread($conn);
        // do something
        // $response = "hello world";
        fwrite($response);
        fclose($conn);
        exit(0);
    }
}

多进程/线程模型的流程是:

创建一个 socket澳门新葡亰网址,,绑定服务器端口(bind),监听端口(listen),在
PHP 中用 stream_socket_server 一个函数就能完成上面 3
个步骤,当然也可以使用更底层的sockets 扩展分别实现。

进入 while 循环,阻塞在 accept 操作上,等待客户端连接进入。此时程序会进入睡眠状态,直到有新的客户端发起 connect 到服务器,操作系统会唤醒此进程。accept 函数返回客户端连接的 socket 主进程在多进程模型下通过 fork(php:
pcntl_fork)创建子进程,多线程模型下使用 pthread_create(php: new
Thread)创建子线程。

下文如无特殊声明将使用进程同时表示进程/线程。

子进程创建成功后进入 while 循环,阻塞在 recv(php:fread)调用上,等待客户端向服务器发送数据。收到数据后服务器程序进行处理然后使用 send(php:
fwrite)向客户端发送响应。长连接的服务会持续与客户端交互,而短连接服务一般收到响应就会 close

当客户端连接关闭时,子进程退出并销毁所有资源,主进程会回收掉此子进程。

澳门新葡亰网址 3

这种模式最大的问题是,进程创建和销毁的开销很大。所以上面的模式没办法应用于非常繁忙的服务器程序。对应的改进版解决了此问题,这就是经典的 Leader-Follower 模型。

$serv = stream_socket_server("tcp://0.0.0.0:8000", $errno, $errstr) 
or die("Create server failed");
for($i = 0; $i < 32; $i++) {
    if (pcntl_fork() == 0) {
        while(1) {
            $conn = stream_socket_accept($serv);
            if ($conn == false) continue;
            // do something
            $request = fread($conn);
            // $response = "hello world";
            fwrite($response);
            fclose($conn);
        }
        exit(0);
    }
}

它的特点是程序启动后就会创建 N
个进程。每个子进程进入 Accept,等待新的连接进入。当客户端连接到服务器时,其中一个子进程会被唤醒,开始处理客户端请求,并且不再接受新的
TCP
连接。当此连接关闭时,子进程会释放,重新进入 Accept,参与处理新的连接。

这个模型的优势是完全可以复用进程,没有额外消耗,性能非常好。很多常见的服务器程序都是基于此模型的,比如
Apache、PHP-FPM。

多进程模型也有一些缺点。

这种模型严重依赖进程的数量解决并发问题,一个客户端连接就需要占用一个进程,工作进程的数量有多少,并发处理能力就有多少。操作系统可以创建的进程数量是有限的。

启动大量进程会带来额外的进程调度消耗。数百个进程时可能进程上下文切换调度消耗占
CPU 不到 1%
可以忽略不计,如果启动数千甚至数万个进程,消耗就会直线上升。调度消耗可能占到
CPU 的百分之几十甚至 100%。

1.1 构建简单迭代器

In [146]: test_iter = iter([i for i in range(1,4)]) 

In [147]: test_iter
Out[147]: <list_iterator at 0x84002a1f60>

返回列表迭代器对象,实际上实现了iterator.__iter__()。

Yii2 Query

在喜闻乐见的各种 PHP 框架里有不少生成器的实例,比如 Yii2 中用来构建 SQL
语句的 yiidbQuery类:

$query = (new yiidbQuery)->from('user');
// yiidbBatchQueryResult
foreach ($query->batch() as $users) {
    // 每次循环得到多条 user 记录
}

来看一下 batch() 做了什么:

/**
* Starts a batch query.
*
* A batch query supports fetching data in batches, which can keep the memory usage under a limit.
* This method will return a [[BatchQueryResult]] object which implements the [[Iterator]] interface
* and can be traversed to retrieve the data in batches.
*
* For example,
*
*
* $query = (new Query)->from('user');
* foreach ($query->batch() as $rows) {
*     // $rows is an array of 10 or fewer rows from user table
* }
*
*
* @param integer $batchSize the number of records to be fetched in each batch.
* @param Connection $db the database connection. If not set, the "db" application component will be used.
* @return BatchQueryResult the batch query result. It implements the [[Iterator]] interface
* and can be traversed to retrieve the data in batches.
*/
public function batch($batchSize = 100, $db = null)
{
   return Yii::createObject([
       'class' => BatchQueryResult::className(),
       'query' => $this,
       'batchSize' => $batchSize,
       'db' => $db,
       'each' => false,
   ]);
}

实际上返回了一个 BatchQueryResult 类,类的源码实现了 Iterator 接口 5
个关键方法:

class BatchQueryResult extends Object implements Iterator
{
    public $db;
    public $query;
    public $batchSize = 100;
    public $each = false;
    private $_dataReader;
    private $_batch;
    private $_value;
    private $_key;
    /**
     * Destructor.
     */
    public function __destruct()
    {
        // make sure cursor is closed
        $this->reset();
    }
    /**
     * Resets the batch query.
     * This method will clean up the existing batch query so that a new batch query can be performed.
     */
    public function reset()
    {
        if ($this->_dataReader !== null) {
            $this->_dataReader->close();
        }
        $this->_dataReader = null;
        $this->_batch = null;
        $this->_value = null;
        $this->_key = null;
    }
    /**
     * Resets the iterator to the initial state.
     * This method is required by the interface [[Iterator]].
     */
    public function rewind()
    {
        $this->reset();
        $this->next();
    }
    /**
     * Moves the internal pointer to the next dataset.
     * This method is required by the interface [[Iterator]].
     */
    public function next()
    {
        if ($this->_batch === null || !$this->each || $this->each && next($this->_batch) === false) {
            $this->_batch = $this->fetchData();
            reset($this->_batch);
        }
        if ($this->each) {
            $this->_value = current($this->_batch);
            if ($this->query->indexBy !== null) {
                $this->_key = key($this->_batch);
            } elseif (key($this->_batch) !== null) {
                $this->_key++;
            } else {
                $this->_key = null;
            }
        } else {
            $this->_value = $this->_batch;
            $this->_key = $this->_key === null ? 0 : $this->_key + 1;
        }
    }
    /**
     * Fetches the next batch of data.
     * @return array the data fetched
     */
    protected function fetchData()
    {
        // ...
    }
    /**
     * Returns the index of the current dataset.
     * This method is required by the interface [[Iterator]].
     * @return integer the index of the current row.
     */
    public function key()
    {
        return $this->_key;
    }
    /**
     * Returns the current dataset.
     * This method is required by the interface [[Iterator]].
     * @return mixed the current dataset.
     */
    public function current()
    {
        return $this->_value;
    }
    /**
     * Returns whether there is a valid dataset at the current position.
     * This method is required by the interface [[Iterator]].
     * @return boolean whether there is a valid dataset at the current position.
     */
    public function valid()
    {
        return !empty($this->_batch);
    }
}

以迭代器的方式实现了类似分页取的效果,同时避免了一次性取出所有数据占用太多的内存空间。

2.2 利用函数定义生成器

In [173]: def test_gene(a):
     ...:     print("第一步")
     ...:     yield a
     ...:     a += 1
     ...:     print("第二步")
     ...:     yield a
     ...:     a += 1
     ...:     print("第三步")
     ...:     yield a
     ...:     a += 1
     ...: 
     ...: 
     ...: g = test_gene(1)  

In [174]: g
Out[174]: <generator object test_gene at 0x0000008400295620>

In [175]: g.__next__()
第一步
Out[175]: 1

In [176]: g.__next__()
第二步
Out[176]: 2

In [177]: g.__next__()
第三步
Out[177]: 3

In [178]: g.__next__()
Traceback (most recent call last):

  File "<ipython-input-178-60e4a84be5d7>", line 1, in <module>
    g.__next__()

StopIteration

可以看出如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator。在每次调用next()的时候执行:

  • 遇到yield语句返回;
  • 保留上下文环境(保留局部变量状态);
  • 再次执行时从上次返回的yield语句处继续执行。

总的来说生成器是一类特殊迭代器,一个产生值的函数 yield
是一种产生一个迭代器却不需要构建迭代器的精密小巧的方法。很明显可以看出生成器(Generator)是采用边循环边计算的机制,当我们只需访问一个大列表的前几个元素的情况下可以不必创建完整的list,从而节省大量的空间。

迭代器使用场景

  • 使用返回迭代器的包或库时(如 PHP5 中的 SPL 迭代器)
  • 无法在一次调用获取所需的所有元素时
  • 要处理数量巨大的元素时(数据库中要处理的结果集内容超过内存)

1.2 调用next()

In [148]: next(test_iter)
Out[148]: 1

In [149]: next(test_iter)
Out[149]: 2

In [150]: next(test_iter)
Out[150]: 3

In [151]: next(test_iter)
Traceback (most recent call last):

  File "<ipython-input-151-ca50863582b2>", line 1, in <module>
    next(test_iter)

StopIteration
In [152]: 

可以看出next()实际调用了iterator.__next__()方法,每次调用更新iterator状态,令其指向后一项,以便下一次调用并返回当前结果。

协程非阻塞 IO

若想真正的发挥出协程的作用,那一定是在一些涉及到阻塞 IO
的场景,我们都知道 Web 服务器最耗时的部分通常都是 socket
读取数据等操作上,如果进程对每个请求都挂起的等待 IO
操作,那处理效率就太低了,接下来我们看个支持非阻塞 IO 的 Scheduler:

<?php
class Scheduler
{
    protected $maxTaskId = 0;
    protected $tasks = []; // taskId => task
    protected $queue;
    // resourceID => [socket, tasks]
    protected $waitingForRead = [];
    protected $waitingForWrite = [];

    public function __construct() {
        // SPL 队列
        $this->queue = new SplQueue();
    }

    public function newTask(Generator $coroutine) {
        $tid = ++$this->maxTaskId;
        $task = new Task($tid, $coroutine);
        $this->tasks[$tid] = $task;
        $this->schedule($task);
        return $tid;
    }

    public function schedule(Task $task) {
        // 任务入队
        $this->queue->enqueue($task);
    }

    public function run() {
        while (!$this->queue->isEmpty()) {
            // 任务出队
            $task = $this->queue->dequeue();
            $task->run();

            if ($task->isFinished()) {
                unset($this->tasks[$task->getTaskId()]);
            } else {
                $this->schedule($task);
            }
        }
    }
    public function waitForRead($socket, Task $task)
    {
        if (isset($this->waitingForRead[(int)$socket])) {
            $this->waitingForRead[(int)$socket][1][] = $task;
        } else {
            $this->waitingForRead[(int)$socket] = [$socket, [$task]];
        }
    }
    public function waitForWrite($socket, Task $task)
    {
        if (isset($this->waitingForWrite[(int)$socket])) {
            $this->waitingForWrite[(int)$socket][1][] = $task;
        } else {
            $this->waitingForWrite[(int)$socket] = [$socket, [$task]];
        }
    }
    /**
     * @param $timeout 0 represent
     */
    protected function ioPoll($timeout)
    {
        $rSocks = [];
        foreach ($this->waitingForRead as list($socket)) {
            $rSocks[] = $socket;
        }
        $wSocks = [];
        foreach ($this->waitingForWrite as list($socket)) {
            $wSocks[] = $socket;
        }
        $eSocks = [];
        // $timeout 为 0 时, stream_select 为立即返回,为 null 时则会阻塞的等,见 http://php.net/manual/zh/function.stream-select.php
        if (!@stream_select($rSocks, $wSocks, $eSocks, $timeout)) {
            return;
        }
        foreach ($rSocks as $socket) {
            list(, $tasks) = $this->waitingForRead[(int)$socket];
            unset($this->waitingForRead[(int)$socket]);
            foreach ($tasks as $task) {
                $this->schedule($task);
            }
        }
        foreach ($wSocks as $socket) {
            list(, $tasks) = $this->waitingForWrite[(int)$socket];
            unset($this->waitingForWrite[(int)$socket]);
            foreach ($tasks as $task) {
                $this->schedule($task);
            }
        }
    }
    /**
     * 检查队列是否为空,若为空则挂起的执行 stream_select,否则检查完 IO 状态立即返回,详见 ioPoll()
     * 作为任务加入队列后,由于 while true,会被一直重复的加入任务队列,实现每次任务前检查 IO 状态
     * @return Generator object for newTask
     *
     */
    protected function ioPollTask()
    {
        while (true) {
            if ($this->taskQueue->isEmpty()) {
                $this->ioPoll(null);
            } else {
                $this->ioPoll(0);
            }
            yield;
        }
    }
    /**
     * $scheduler = new Scheduler;
     * $scheduler->newTask(Web Server Generator);
     * $scheduler->withIoPoll()->run();
     *
     * 新建 Web Server 任务后先执行 withIoPoll() 将 ioPollTask() 作为任务入队
     * 
     * @return $this
     */
    public function withIoPoll()
    {
        $this->newTask($this->ioPollTask());
        return $this;
    }
}

这个版本的 Scheduler
里加入一个永不退出的任务,并且通过 stream_select 支持的特性来实现快速的来回检查各个任务的
IO 状态,只有 IO 完成的任务才会继续执行,而 IO
还未完成的任务则会跳过,完整的代码和例子可以戳这里。

也就是说任务交替执行的过程中,一旦遇到需要 IO 的部分,调度器就会把 CPU
时间分配给不需要 IO 的任务,等到当前任务遇到 IO 或者之前的任务 IO
结束才再次调度 CPU 时间,以此实现 CPU 和 IO
并行来提升执行效率,类似下图:

澳门新葡亰网址 4

2.1 创建简单生成器

其创建方法区别于列表创建方式,在此采用()而非[]

In [163]: test_gene = (x * x for x in range(1,4))

In [164]: test_gene
Out[164]: <generator object <genexpr> at 0x00000084002AD8E0>

In [166]: test_gene.__next__()
Out[166]: 1

In [167]: test_gene.__next__()
Out[167]: 4

In [168]: test_gene.__next__()
Out[168]: 9

In [169]: test_gene.__next__()
Traceback (most recent call last):

  File "<ipython-input-169-e6166353d257>", line 1, in <module>
    test_gene.__next__()

StopIteration

PHP 协程和 yield

PHP 从 5.5 开始支持生成器及 yield 关键字,而 PHP
协程则由 yield 来实现。

要理解协程,首先要理解:代码是代码,函数是函数。函数包裹的代码赋予了这段代码附加的意义:不管是否显式的指明返回值,当函数内的代码块执行完后都会返回到调用层。而当调用层调用某个函数的时候,必须等这个函数返回,当前函数才能继续执行,这就构成了后进先出,也就是 Stack

而协程包裹的代码,不是函数,不完全遵守函数的附加意义,协程执行到某个点,协会协程会 yield返回一个值然后挂起,而不是 return 一个值然后结束,当再次调用协程的时候,会在上次 yield 的点继续执行。

所以协程违背了通常操作系统和 x86 的 CPU
认定的代码执行方式,也就是 Stack 的这种执行方式,需要运行环境(比如
php,python 的 yield 和 golang 的
goroutine)自己调度,来实现任务的中断和恢复,具体到
PHP,就是靠 yield 来实现。

堆栈式调用 和 协程调用的对比:

澳门新葡亰网址 5

结合之前的例子,可以总结一下 yield 能做的就是:

  • 实现不同任务间的主动让位、让行,把控制权交回给任务调度器。
  • 通过 send() 实现不同任务间的双向通信,也就可以实现任务和调度器之间的通信。

yield 就是 PHP 实现协程的方式。

1 迭代(iteration)与迭代器(iterator)

迭代是重复反馈过程的活动,其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次“迭代”,而每一次迭代得到的结果会被用来作为下一次迭代的初始值。(维基百科)

iterator是实现了iterator.__iter__()和iterator.__next__()方法的对象iterator.__iter__()方法返回的是iterator对象本身。

协程

对于单核处理器,多进程实现多任务的原理是让操作系统给一个任务每次分配一定的
CPU
时间片,然后中断、让下一个任务执行一定的时间片接着再中断并继续执行下一个,如此反复。由于切换执行任务的速度非常快,给外部用户的感受就是多个任务的执行是同时进行的。

多进程的调度是由操作系统来实现的,进程自身不能控制自己何时被调度,也就是说:

进程的调度是由外层调度器抢占式实现的

协程要求当前正在运行的任务自动把控制权回传给调度器,这样就可以继续运行其他任务。这与『抢占式』的多任务正好相反,
抢占多任务的调度器可以强制中断正在运行的任务,
不管它自己有没有意愿。『协作式多任务』在 Windows 的早期版本 (windows95)
和 Mac OS 中有使用,
不过它们后来都切换到『抢占式多任务』了。理由相当明确:如果仅依靠程序自动交出控制的话,那么一些恶意程序将会很容易占用全部
CPU 时间而不与其他任务共享。

协程的调度是由协程自身主动让出控制权到外层调度器实现的

回到刚才生成器实现 xrange 函数的例子,整个执行过程的交替可以用下图来表示:

澳门新葡亰网址 6

协程可以理解为纯用户态的线程,通过协作而不是抢占来进行任务切换。相对于进程或者线程,协程所有的操作都可以在用户态而非操作系统内核态完成,创建和切换的消耗非常低。

简单的说 Coroutine(协程) 就是提供一种方法来中断当前任务的执行,保存当前的局部变量,下次再过来又可以恢复当前局部变量继续执行。

我们可以把大任务拆分成多个小任务轮流执行,如果有某个小任务在等待系统
IO,就跳过它,执行下一个小任务,这样往复调度,实现了 IO 操作和 CPU
计算的并行执行,总体上就提升了任务的执行效率,这也便是协程的意义。

4.1 概念理解

异步是区别于同步,这里的同步指的并不是所有线程同时进行,而是所有线程在时间轴上有序进行。在实际的IO操作的过程中,当前线程被挂起,而其他需要CPU执行的代码就无法被当前线程执行了。异步正是为解决CPU高速执行能力和IO设备的龟速严重不匹配,当代码需要执行一个耗时的IO操作时,它只发出IO指令,并不等待IO结果,然后就去执行其他代码了。一段时间后,当IO返回结果时,再通知CPU进行处理。
  异步IO是基于CPU与IO处理速度不一致并为了充分利用资源的方法之一,在上一篇《Python知识(1)——并发编程》中记录到的多线程与多进程也是该问题的处理方法之一。

澳门新葡亰网址 7

图片来自网络

区别

  • 『并发』指的是程序的结构,『并行』指的是程序运行时的状态
  • 『并行』一定是并发的,『并行』是『并发』设计的一种
  • 单线程永远无法达到『并行』状态

正确的并发设计的标准是:

使多个操作可以在重叠的时间段内进行。
two tasks can start, run, and complete in overlapping time periods

参考:


发表评论

电子邮件地址不会被公开。 必填项已用*标注

相关文章

网站地图xml地图