https://juejin.im/post/5d5375baf265da03b2152f3d

前几天，有个搞培训的朋友，和我要一份java后端的进阶路线图，我就把这篇文章发给了他《必看！java后端，亮剑诛仙》。今天，又想要个java后端目前最常用的工具和框架，正好我以前画过这样一张图，于是发给了他。虽然不是很全，但也希望得到他的夸奖。没想到…

本篇内容涵盖14个方面，涉及上百个框架和工具。会有你喜欢的，大概也会有你所讨厌的家伙。这是我平常工作中打交道最多的工具，大小公司都适用。如果你有更好的，欢迎留言补充。

一、消息队列
二、缓存
三、分库分表
四、数据同步
五、通讯
六、微服务
七、分布式工具
八、监控系统
九、调度
十、入口工具
十一、OLT（A）P
十二、CI/CD
十三、问题排查
十四、本地工具
复制代码

一、消息队列

一个大型的分布式系统，通常都会异步化，走消息总线。 消息队列作为最主要的基础组件，在整个体系架构中，有着及其重要的作用。kafka是目前最常用的消息队列，尤其是在大数据方面，有着极高的吞吐量。而rocketmq和rabbitmq，都是电信级别的消息队列，在业务上用的比较多。2019年了，不要再盯着JMS不放了（说的就是臃肿的ActiveMQ）。

pulsar是为了解决一些kafka上的问题而诞生的消息系统，比较年轻，工具链有限。有些激进的团队经过试用，反响不错。

mqtt具体来说是一种协议，主要用在物联网方面，能够双向通信，属于消息队列范畴。

二、缓存

数据缓存是减少数据库压力的有效途径，有单机java内缓存，和分布式缓存之分。

对于单机来说，guava的cache和ehcache都是些熟面孔。

对于分布式缓存来说，优先选择的就是redis，别犹豫。由于redis是单线程的，并不适合高耗时操作。所以对于一些数据量比较大的缓存，比如图片、视频等，使用老牌的memcached效果会好的多。

JetCache是一个基于Java的缓存系统封装，提供统一的api和注解来简化缓存的使用。类似SpringCache，支持本地缓存和分布式缓存，是简化开发的利器。

三、分库分表

分库分表，几乎每一个上点规模的公司，都会有自己的方案。目前，推荐使用驱动层的sharding-jdbc，或者代理层的mycat。如果你没有额外的运维团队，又不想花钱买其他机器，那么就选前者。

如果分库分表涉及的项目不多，spring的动态数据源是一个非常好的选择。它直接编码在代码里，直观但不易扩展。

如果只需要读写分离 ，那么mysql官方驱动里的replication协议，是更加轻量级的选择。

上面的分库分表组件，都是大浪淘沙，最终的优胜品。这些组件不同于其他组件选型，方案一旦确定，几乎无法回退，所以要慎之又慎。

分库分表是小case，准备分库分表的阶段，才是重点：也就是数据同步。

四、数据同步

国内使用mysql的公司居多，但postgresql凭借其优异的性能，使用率逐渐攀升。

不管什么数据库，实时数据同步工具，都是把自己模拟成一个从库，进行数据拉取和解析。 具体来说，mysql是通过binlog进行同步；postgresql使用wal日志进行同步。

对mysql来说，canal是国内用的最多的方案；类似的databus也是比较好用的工具。

现在，canal、maxwell等工具，都支持将要同步的数据写入到mq中，进行后续处理，方便了很多。

对于ETL（抽取、清洗、转换）来说，基本上都是source、task、sink路线，与前面的功能对应。gobblin、datax、logstash、sqoop等，都是这样的工具。

它们的主要工作，就是怎么方便的定义配置文件，编写各种各样的数据源适配接口等。这些ETL工具，也可以作为数据同步（尤其是全量同步）的工具，通常是根据ID，或者最后更新时间 等，进行处理。

binlog是实时增量工具，ETL工具做辅助。通常一个数据同步功能，需要多个组件的参与，他们共同组成一个整体。

五、通讯

Java 中，netty已经成为当之无愧的网络开发框架，包括其上的socketio（不要再和我提mina了）。对于http协议，有common-httpclient，以及更加轻量级的工具okhttp来支持。

对于一个rpc来说，要约定一个通讯方式和序列化方式。json是最常用的序列化方式，但是传输和解析成本大，xml等文本协议与其类似，都有很多冗余的信息；avro和kryo是二进制的序列化工具，没有这些缺点，但调试不便。

rpc是远程过程调用的意思 ，其中，thrift、dubbo、gRPC默认都是二进制序列化方式的socket通讯框架；feign、hessian都是onhttp的远程调用框架。

对了，gRPC的序列化工具是protobuf，一个压缩比很高的二进制序列化工具。

通常，服务的响应时间主要耗费在业务逻辑以及数据库上，通讯层耗时在其中的占比很小。可以根据自己公司的研发水平和业务规模来选择。

六、微服务

我们不止一次说到微服务，这一次我们从围绕它的一堆支持框架，来窥探一下这个体系。是的，这里依然是在说spring cloud。

默认的注册中心eureka不再维护，consul已经成为首选。nacos、zookeeper等，都可以作为备选方案。其中nacos带有后台，比较适合国人使用习惯。

熔断组件，官方的hystrix也已经不维护了。推荐使用resilience4j，最近阿里的sentinel也表现强劲。

对于调用链来说，由于OpenTracing的兴起，有了很多新的面孔。推荐使用jaeger或者skywalking。spring cloud集成的sleuth+zipkin功能稍弱，甚至不如传统侵入式的cat。

配置中心是管理多环境配置文件的利器，尤其在你不想重启服务器的情况下进行配置更新。目前，开源中做的最好的要数apollo，并提供了对spring boot的支持。disconf使用也较为广泛。相对来说，spring cloud config功能就局限了些，用的很少。

---

网关方面，使用最多的就是nginx，在nginx之上，有基于lua脚本的openrestry。由于openresty的使用非常繁杂，所以有了kong这种封装级别更高的网关。

对于spring cloud来说，zuul系列推荐使用zuul2，zuul1是多线程阻塞的，有硬伤。spring-cloud-gateway是spring cloud亲生的，但目前用的不是很广泛。

七、分布式工具

大家都知道分布式系统zookeeper能用在很多场景，与其类似的还有基于raft协议的etcd和consul。

由于它们能够保证极高的一致性，所以用作协调工具是再好不过了。用途集中在：配置中心、分布式锁、命名服务、分布式协调、master选举等场所。

对于分布式事务方面，则有阿里的fescar工具进行支持。但如非特别的必要，还是使用柔性事务，追寻最终一致性，比较好。

八、监控系统

监控系统组件种类繁多，目前，最流行的大概就是上面四类。

zabbix在主机数量不多的情况下，是非常好的选择。

prometheus来势凶猛，大有一统天下的架势。它也可以使用更加漂亮的grafana进行前端展示。

influxdata的influxdb和telegraf组件，都比较好用，主要是功能很全。

使用es存储的elkb工具链，也是一个较好的选择。我所知道的很多公司，都在用。

九、调度

大家可能都用过cron表达式。这个表达式，最初就是来自linux的crontab工具。

quartz是java中比较古老的调度方案，分布式调度采用数据库锁的方式，管理界面需要自行开发。

elastic-job-cloud应用比较广泛，但系统运维复杂，学习成本较高。相对来说，xxl-job就更加轻量级一些。中国人开发的系统，后台都比较漂亮。

十、入口工具

为了统一用户的访问路口，一般会使用一些入口工具进行支持。

其中，haproxy、lvs、keepalived等，使用非常广泛。

服务器一般采用稳定性较好的centos，并配备ansible工具进行支持，那叫一个爽。

十一、OLT（A）P

现在的企业，数据量都非常大，数据仓库是必须的。

搜索方面，solr和elasticsearch比较流行，它们都是基于lucene的。solr比较成熟，稳定性更好一些，但实时搜索方面不如es。

列式存储方面，基于Hadoop 的hbase，使用最是广泛；基于LSM的leveldb写入性能优越，但目前主要是作为嵌入式引擎使用多一些。

tidb是国产新贵，兼容mysql协议，公司通过培训向外输出dba，未来可期。

时序数据库方面，opentsdb用在超大型监控系统多一些。druid和kudu，在处理多维度数据实时聚合方面，更胜一筹。

cassandra在刚出现时火了一段时间，虽然有facebook弃用的新闻，但生态已经形成，常年霸占数据库引擎前15名。

十二、CI/CD

为了支持持续集成和虚拟化，除了耳熟能详的docker，我们还有其他工具。

jenkins是打包发布的首选，毕竟这么多年了，一直是老大哥。当然，写Idea的那家公司，还出了一个叫TeamCity的工具，操作界面非常流畅。

sonar（注意图上的错误）不得不说是一个神器，用了它之后，小伙伴们的代码一片飘红，我都快被吐沫星子给淹没了。

对于公司内部来说，一般使用gitlab搭建git服务器。其实，它里面的gitlab CI，也是非常好用的。

十三、问题排查

java经常发生内存溢出问题。使用jmap导出堆栈后，我一般使用mat进行深入分析。

如果在线上实时分析，有arthas和perf两款工具。

当然，有大批量的linux工具进行支持。比如下面这些：

《Linux上，最常用的一批命令解析（10年精选）》

十四、本地工具

本地使用的jar包和工具，那就多了去了。下面仅仅提一下最最常用的几个。

数据库连接池方面，国内使用druid最多。目前，有号称速度最快的hikari数据库连接池，以及老掉牙的dbcp和c3p0。

json方面，国内使用fastjson最多，三天两头冒出个漏洞；国外则使用jackson多一些。它们的api都类似，jackson特性多一些，但fastjson更加容易使用。

工具包方面，虽然有各种commons包，guava首选。

End

今天是2019年8月13日。台风利奇马刚刚肆虐完毕。

这种文章，每一年我都会整理一次。有些新面孔，也有些被我个人t出局。架构选型，除了你本身对某项技术比较熟悉，用起来更放心。更多的是需要进行大量调研、对比，直到掌握。

技术日新月异，新瓶装旧酒，名词一箩筐，程序员很辛苦。唯有那背后的基础原理，大道至简的思想，经久不衰。

作者：小姐姐味道
链接：https://juejin.im/post/5d5375baf265da03b2152f3d
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

之前看博客上总有人抓某个网站，然后做一张炫酷的词频统计图。虽然知道有现成的库，但是一直没机会实践。这次刚好试验一下，比较简单。

#-*- encoding:utf-8 -*-
import matplotlib.pyplot as plt
import jieba
from wordcloud import WordCloud
import collections

#1.读出歌词
text = open('./words.txt','r').read()
#2.把歌词剪开
cut_text = jieba.cut(text)
# print(type(cut_text))
# print(next(cut_text))
# print(next(cut_text))
#3.以空格拼接起来
remove_words = [u'的', u'，',u'和', u'是', u'随着', u'对于', u'对',u'等',u'能', \
    u'都',u'。',u' ',u'、',u'中',u'在',u'了',u'通常',u'如果',u'我',u'需要',u'自己',\
    u'你',u'人',u'不',u'就',u'有',u'一个',u'也',u'而是',u'只是',u'可以',u'不要', \
    u'还是',u'不能',u'所有',u'那些',u'不会',u'那么',u'因为',u'只有',u'那些',u'也']
filter_words = [u'的', u'是',u'那', u'不']
object_list = []
#过滤词
for word in cut_text :
    if len(word) <= 1:
        continue

    flag = True
    if word not in remove_words: # 如果不在去除词库中
        for tmp_filter in filter_words :
            if word.find(tmp_filter) != -1 :
                flag = False
                break;
        if flag:
            object_list.append(word) 

word_counts = collections.Counter(object_list) # 对分词做词频统计
word_counts_top = word_counts.most_common(50) # 获取前10最高频的词
print word_counts_top

# print(result)
# 4.生成词云
wc = WordCloud(
    font_path='./YC.ttf',     #字体路径
    background_color='white',   #背景颜色
    width=1000,
    height=600,
    max_font_size=50,            #字体大小
    min_font_size=10,
    #mask=plt.imread('xin.jpg'),  #背景图片
    max_words=50
)
wc.generate_from_frequencies(word_counts)
wc.to_file('fin.png')    #图片保存

#5.显示图片
plt.figure('jielun')   #图片显示的名字
plt.imshow(wc)
plt.axis('off')        #关闭坐标
plt.show()

这里可以设置背景图片和字体格式。对于中文，一定要有ttf字体文件。我随便从github上找了一种字体。
亲测可用！

转：https://segmentfault.com/a/1190000012457145?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io

相信大家都听说过『协程』这个概念吧。

但是有些同学对这个概念似懂非懂，不知道怎么实现，怎么用，用在哪，甚至有些人认为yield就是协程！

我始终相信，如果你无法准确地表达出一个知识点的话，我可以认为你就是不懂。

如果你之前了解过利用PHP实现协程的话，你肯定看过鸟哥的那篇文章：在PHP中使用协程实现多任务调度| 风雪之隅

鸟哥这篇文章是从国外的作者翻译来的，翻译的简洁明了，也给出了具体的例子了。

我写这篇文章的目的，是想对鸟哥文章做更加充足的补充，毕竟有部分同学的基础还是不够好，看得也是云头雾里的。

我个人，不喜欢写长篇文章，微博关注我 @码云 ，每天用微博分享知识。文章同时记录在我的博客：https://bruceit.com/p/A4kSfE

什么是协程

先搞清楚，什么是协程。

你可能已经听过『进程』和『线程』这两个概念。

进程就是二进制可执行文件在计算机内存里的一个运行实例，就好比你的.exe文件是个类，进程就是new出来的那个实例。

进程是计算机系统进行资源分配和调度的基本单位（调度单位这里别纠结线程进程的），每个CPU下同一时刻只能处理一个进程。

所谓的并行，只不过是看起来并行，CPU事实上在用很快的速度切换不同的进程。

进程的切换需要进行系统调用，CPU要保存当前进程的各个信息，同时还会使CPUCache被废掉。

所以进程切换不到非不得已就不做。

那么怎么实现『进程切换不到非不得已就不做』呢？

首先进程被切换的条件是：进程执行完毕、分配给进程的CPU时间片结束，系统发生中断需要处理，或者进程等待必要的资源（进程阻塞）等。你想下，前面几种情况自然没有什么话可说，但是如果是在阻塞等待，是不是就浪费了。

其实阻塞的话我们的程序还有其他可执行的地方可以执行，不一定要傻傻的等！

所以就有了线程。

线程简单理解就是一个『微进程』，专门跑一个函数（逻辑流）。

所以我们就可以在编写程序的过程中将可以同时运行的函数用线程来体现了。

线程有两种类型，一种是由内核来管理和调度。

我们说，只要涉及需要内核参与管理调度的，代价都是很大的。这种线程其实也就解决了当一个进程中，某个正在执行的线程遇到阻塞，我们可以调度另外一个可运行的线程来跑，但是还是在同一个进程里，所以没有了进程切换。

还有另外一种线程，他的调度是由程序员自己写程序来管理的，对内核来说不可见。这种线程叫做『用户空间线程』。

协程可以理解就是一种用户空间线程。

协程，有几个特点：

• 协同，因为是由程序员自己写的调度策略，其通过协作而不是抢占来进行切换
• 在用户态完成创建，切换和销毁
• ⚠️ 从编程角度上看，协程的思想本质上就是控制流的主动让出（yield）和恢复（resume）机制
• generator经常用来实现协程

说到这里，你应该明白协程的基本概念了吧？

PHP实现协程

一步一步来，从解释概念说起！

可迭代对象

PHP5提供了一种定义对象的方法使其可以通过单元列表来遍历，例如用foreach语句。

你如果要实现一个可迭代对象，你就要实现Iterator接口：

<?php
class MyIterator implements Iterator
{
    private $var = array();

    public function __construct($array)
    {
        if (is_array($array)) {
            $this->var = $array;
        }
    }

    public function rewind() {
        echo "rewinding\n";
        reset($this->var);
    }

    public function current() {
        $var = current($this->var);
        echo "current: $var\n";
        return $var;
    }

    public function key() {
        $var = key($this->var);
        echo "key: $var\n";
        return $var;
    }

    public function next() {
        $var = next($this->var);
        echo "next: $var\n";
        return $var;
    }

    public function valid() {
        $var = $this->current() !== false;
        echo "valid: {$var}\n";
        return $var;
    }
}

$values = array(1,2,3);
$it = new MyIterator($values);

foreach ($it as $a => $b) {
    print "$a: $b\n";
}

生成器

可以说之前为了拥有一个能够被foreach遍历的对象，你不得不去实现一堆的方法，yield关键字就是为了简化这个过程。

生成器提供了一种更容易的方法来实现简单的对象迭代，相比较定义类实现Iterator接口的方式，性能开销和复杂性大大降低。

<?php
function xrange($start, $end, $step = 1) {
    for ($i = $start; $i <= $end; $i += $step) {
        yield $i;
    }
}
 
foreach (xrange(1, 1000000) as $num) {
    echo $num, "\n";
}

记住，一个函数中如果用了yield，他就是一个生成器，直接调用他是没有用的，不能等同于一个函数那样去执行！

所以，yield就是yield，下次谁再说yield是协程，我肯定把你xxxx。

PHP协程

前面介绍协程的时候说了，协程需要程序员自己去编写调度机制，下面我们来看这个机制怎么写。

0）生成器正确使用

既然生成器不能像函数一样直接调用，那么怎么才能调用呢？

方法如下：

1. foreach他
2. send($value)
3. current / next…

1）Task实现

Task就是一个任务的抽象，刚刚我们说了协程就是用户空间协程，线程可以理解就是跑一个函数。

所以Task的构造函数中就是接收一个闭包函数，我们命名为coroutine。

/**
 * Task任务类
 */
class Task
{
    protected $taskId;
    protected $coroutine;
    protected $beforeFirstYield = true;
    protected $sendValue;

    /**
     * Task constructor.
     * @param $taskId
     * @param Generator $coroutine
     */
    public function __construct($taskId, Generator $coroutine)
    {
        $this->taskId = $taskId;
        $this->coroutine = $coroutine;
    }

    /**
     * 获取当前的Task的ID
     * 
     * @return mixed
     */
    public function getTaskId()
    {
        return $this->taskId;
    }

    /**
     * 判断Task执行完毕了没有
     * 
     * @return bool
     */
    public function isFinished()
    {
        return !$this->coroutine->valid();
    }

    /**
     * 设置下次要传给协程的值，比如 $id = (yield $xxxx)，这个值就给了$id了
     * 
     * @param $value
     */
    public function setSendValue($value)
    {
        $this->sendValue = $value;
    }

    /**
     * 运行任务
     * 
     * @return mixed
     */
    public function run()
    {
        // 这里要注意，生成器的开始会reset，所以第一个值要用current获取
        if ($this->beforeFirstYield) {
            $this->beforeFirstYield = false;
            return $this->coroutine->current();
        } else {
            // 我们说过了，用send去调用一个生成器
            $retval = $this->coroutine->send($this->sendValue);
            $this->sendValue = null;
            return $retval;
        }
    }
}

2）Scheduler实现

接下来就是Scheduler这个重点核心部分，他扮演着调度员的角色。

/**
 * Class Scheduler
 */
Class Scheduler
{
    /**
     * @var SplQueue
     */
    protected $taskQueue;
    /**
     * @var int
     */
    protected $tid = 0;

    /**
     * Scheduler constructor.
     */
    public function __construct()
    {
        /* 原理就是维护了一个队列，
         * 前面说过，从编程角度上看，协程的思想本质上就是控制流的主动让出（yield）和恢复（resume）机制
         * */
        $this->taskQueue = new SplQueue();
    }

    /**
     * 增加一个任务
     *
     * @param Generator $task
     * @return int
     */
    public function addTask(Generator $task)
    {
        $tid = $this->tid;
        $task = new Task($tid, $task);
        $this->taskQueue->enqueue($task);
        $this->tid++;
        return $tid;
    }

    /**
     * 把任务进入队列
     *
     * @param Task $task
     */
    public function schedule(Task $task)
    {
        $this->taskQueue->enqueue($task);
    }

    /**
     * 运行调度器
     */
    public function run()
    {
        while (!$this->taskQueue->isEmpty()) {
            // 任务出队
            $task = $this->taskQueue->dequeue();
            $res = $task->run(); // 运行任务直到 yield

            if (!$task->isFinished()) {
                $this->schedule($task); // 任务如果还没完全执行完毕，入队等下次执行
            }
        }
    }
}

这样我们基本就实现了一个协程调度器。

你可以使用下面的代码来测试：

<?php
function task1() {
    for ($i = 1; $i <= 10; ++$i) {
        echo "This is task 1 iteration $i.\n";
        yield; // 主动让出CPU的执行权
    }
}
 
function task2() {
    for ($i = 1; $i <= 5; ++$i) {
        echo "This is task 2 iteration $i.\n";
        yield; // 主动让出CPU的执行权
    }
}
 
$scheduler = new Scheduler; // 实例化一个调度器
$scheduler->addTask(task1()); // 添加不同的闭包函数作为任务
$scheduler->addTask(task2());
$scheduler->run();

关键说下在哪里能用得到PHP协程。

function task1() {
        /* 这里有一个远程任务，需要耗时10s，可能是一个远程机器抓取分析远程网址的任务，我们只要提交最后去远程机器拿结果就行了 */
        remote_task_commit();
        // 这时候请求发出后，我们不要在这里等，主动让出CPU的执行权给task2运行，他不依赖这个结果
        yield;
        yield (remote_task_receive());
        ...
}
 
function task2() {
    for ($i = 1; $i <= 5; ++$i) {
        echo "This is task 2 iteration $i.\n";
        yield; // 主动让出CPU的执行权
    }
}

这样就提高了程序的执行效率。

关于『系统调用』的实现，鸟哥已经讲得很明白，我这里不再说明。

3）协程堆栈

鸟哥文中还有一个协程堆栈的例子。

我们上面说过了，如果在函数中使用了yield，就不能当做函数使用。

所以你在一个协程函数中嵌套另外一个协程函数：

<?php
function echoTimes($msg, $max) {
    for ($i = 1; $i <= $max; ++$i) {
        echo "$msg iteration $i\n";
        yield;
    }
}
 
function task() {
    echoTimes('foo', 10); // print foo ten times
    echo "---\n";
    echoTimes('bar', 5); // print bar five times
    yield; // force it to be a coroutine
}
 
$scheduler = new Scheduler;
$scheduler->addTask(task());
$scheduler->run();

这里的echoTimes是执行不了的！所以就需要协程堆栈。

不过没关系，我们改一改我们刚刚的代码。

把Task中的初始化方法改下，因为我们在运行一个Task的时候，我们要分析出他包含了哪些子协程，然后将子协程用一个堆栈保存。（C语言学的好的同学自然能理解这里，不理解的同学我建议去了解下进程的内存模型是怎么处理函数调用）

 /**
     * Task constructor.
     * @param $taskId
     * @param Generator $coroutine
     */
    public function __construct($taskId, Generator $coroutine)
    {
        $this->taskId = $taskId;
        // $this->coroutine = $coroutine;
        // 换成这个，实际Task->run的就是stackedCoroutine这个函数，不是$coroutine保存的闭包函数了
        $this->coroutine = stackedCoroutine($coroutine); 
    }

当Task->run()的时候，一个循环来分析：

/**
 * @param Generator $gen
 */
function stackedCoroutine(Generator $gen)
{
    $stack = new SplStack;

    // 不断遍历这个传进来的生成器
    for (; ;) {
        // $gen可以理解为指向当前运行的协程闭包函数（生成器）
        $value = $gen->current(); // 获取中断点，也就是yield出来的值

        if ($value instanceof Generator) {
            // 如果是也是一个生成器，这就是子协程了，把当前运行的协程入栈保存
            $stack->push($gen);
            $gen = $value; // 把子协程函数给gen，继续执行，注意接下来就是执行子协程的流程了
            continue;
        }

        // 我们对子协程返回的结果做了封装，下面讲
        $isReturnValue = $value instanceof CoroutineReturnValue; // 子协程返回`$value`需要主协程帮忙处理
        
        if (!$gen->valid() || $isReturnValue) {
            if ($stack->isEmpty()) {
                return;
            }
            // 如果是gen已经执行完毕，或者遇到子协程需要返回值给主协程去处理
            $gen = $stack->pop(); //出栈，得到之前入栈保存的主协程
            $gen->send($isReturnValue ? $value->getValue() : NULL); // 调用主协程处理子协程的输出值
            continue;
        }

        $gen->send(yield $gen->key() => $value); // 继续执行子协程
    }
}

然后我们增加echoTime的结束标示：

class CoroutineReturnValue {
    protected $value;
 
    public function __construct($value) {
        $this->value = $value;
    }
     
    // 获取能把子协程的输出值给主协程，作为主协程的send参数
    public function getValue() {
        return $this->value;
    }
}

function retval($value) {
    return new CoroutineReturnValue($value);
}

然后修改echoTimes：

function echoTimes($msg, $max) {
    for ($i = 1; $i <= $max; ++$i) {
        echo "$msg iteration $i\n";
        yield;
    }
    yield retval("");  // 增加这个作为结束标示
}

Task变为：

function task1()
{
    yield echoTimes('bar', 5);
}

这样就实现了一个协程堆栈，现在你可以举一反三了。

4）PHP7中yield from关键字

PHP7中增加了yield from，所以我们不需要自己实现携程堆栈，真是太好了。

把Task的构造函数改回去：

    public function __construct($taskId, Generator $coroutine)
    {
        $this->taskId = $taskId;
        $this->coroutine = $coroutine;
        // $this->coroutine = stackedCoroutine($coroutine); //不需要自己实现了，改回之前的
    }

echoTimes函数：

function echoTimes($msg, $max) {
    for ($i = 1; $i <= $max; ++$i) {
        echo "$msg iteration $i\n";
        yield;
    }
}

task1生成器：

function task1()
{
    yield from echoTimes('bar', 5);
}

这样，轻松调用子协程