不依赖框架写出现代化 PHP 代码 不依赖框架写出现代化 PHP 代码我为你们准备了一个富有挑战性的事情。接下来你们将以 无 框架的方式开启一个项目之旅。首先声明， 这篇并非又臭又长的反框架裹脚布文章。也不是推销 非原创 思想 。毕竟， 我们还将在接下来的开发之旅中使用其他框架开发者编写的辅助包。我对这个领域的创新也是持无可非议的态度。这无关他人，而是关乎己身。作为一名开发者，它将有机会让你成长。也许无框架开发令你受益匪浅的地方就是，可以从底层运作的层面中汲取丰富的知识。抛却依赖神奇的，帮你处理无法调试和无法真正理解的东西的框架，你将清楚的看到这一切是如何发生的。很有可能下一份工作中，你并不能随心所以地选择框架开拓新项目。现实就是，在很多高价值，关键业务的 PHP 工作中均使用现有应用。 并且该应用程序是否构建在当前令人舒爽的 Laravel 或 Symfony 等流行框架中，亦或是陈旧过时的 CodeIgniter 或者 FuelPHP 中，更有甚者它可能广泛出现在令人沮丧的  “面向包含体系结构” 的传统的 PHP 应用 之中，所以无框架开发会在将来你所面临的任何 PHP 项目中助你一臂之力。上古时代， 因为 某些系统 不得不解释分发 HTTP 请求，发送 HTTP 响应，管理依赖关系，无框架开发就是痛苦的鏖战。缺乏行业标准必然意味着，框架中的这些组件高度耦合 。如果你从无框架开始，你终将难逃自建框架的命运。时至今日，幸亏有 PHP-FIG 完成所有的自动加载和交互工作，无框架开发并非让你白手起家。各色供应商都有这么多优秀的可交互的软件包。把他们组合起来容易得超乎你的想象！PHP 是如何工作的？在做其他事之前，搞清楚 PHP 如何与外界沟通是非常重要的。PHP 以请求 / 响应为周期运行服务端应用程序。与你的应用程序的每一次交互 —— 无论是来自浏览器，命令行还是 REST API —— 都是作为请求进入应用程序的。 当接收到请求以后：程序开始启动；开始处理请求；产生响应；接着，响应返回给产生请求的相应客户端；最后程序关闭。每一个 请求都在重复以上的交互。前端控制器用这些知识把自己武装起来以后，就可以先从我们的前端控制器开始编写程序了。前端控制器是一个 PHP 文件，它处理程序的每一个请求。控制器是请求进入程序后遇到的第一个 PHP 文件，并且（本质上）也是响应走出你应用程序所经过的最后一个文件。我们使用经典的 Hello, world! 作为例子来确保所有东西都正确连接上，这个例子由 PHP 的内置服务器  驱动。在你开始这样做之前，请确保你已经安装了 PHP7.1 或者更高版本。创建一个含有 public 目录的项目，然后在该目录里面创建一个 index.php 文件，文件里面写入如下代码：<?phpdeclare(strict_types=1);echo 'Hello, world!';注意，这里我们声明了使用严格模式 —— 作为最佳实践，你应该在应用程序的 每个 PHP 文件的开头 都这样做。因为对从你后面来的开发者来说类型提示对 调试和清晰的交流意图很重要 。使用命令行（比如 macOS 的终端）切换到你的项目目录并启动 PHP 的内置服务器。php -S localhost:8080 -t public/现在，在浏览器中打开 http://localhost:8080/ 。是不是成功地看到了 "Hello, world!" 输出？很好。接下来我们可以开始进入正题了！自动加载与第三方包当你第一次使用 PHP 时，你可能会在你的程序中使用 includes 或 requires 语句来从其他 PHP 文件导入功能和配置。 通常，我们会避免这么干，因为这会使得其他人更难以遵循你的代码路径和理解依赖在哪里。这让调试成为了一个 真正的 噩梦。解决办法是使用自动加载（autoloading）。 自动加载的意思是：当你的程序需要使用一个类， PHP 在调用该类的时候知道去哪里找到并加载它。虽然从 PHP 5 开始就可以使用这个特性了， 但是得益于 PSR-0 （ 自动加载标准，后来被 PSR-4 取代），其使用率才开始有真正的提升。我们可以编写自己的自动加载器来完成任务，但是由于我们将要使用的管理第三方依赖的  Composer 已经包含了一个完美的可用的自动加载器，那我们用它就行了。确保你已经在你的系统上 安装 了 Composer。然后为此项目初始化 Composer：composer init这条命令通过交互式引导你创建 composer.json 配置文件。 一旦文件创建好了，我们就可以在编辑器中打开它然后向里面写入 autoload 字段，使他看起来像这个样子（这确保了自动加载器知道从哪里找到我们项目中的类）：{"name": "kevinsmith/no-framework", "description": "An example of a modern PHP application bootstrapped without a framework.", "type": "project", "require": {}, "autoload": { "psr-4": { "ExampleApp\\": "src/" } }}现在为此项目安装 composer，它引入了依赖（如果有的话），并为我们创建好了自动加载器：composer install更新 public/index.php 文件来引入自动加载器。在理想情况下，这将是你在程序当中使用的少数『包含』语句之一。<?phpdeclare(strict_types=1);require_once dirname(__DIR__) . '/vendor/autoload.php';echo 'Hello, world!';此时如果你刷新浏览器，你将不会看到任何变化。因为自动加载器没有修改或者输出任何数据，所以我们看到的是同样的内容。让我们把 Hello, world! 这个例子移动到一个已经自动加载的类里面看看它是如何运作的。在项目根目录创建一个名为 src 的目录，然后在里面添加一个叫 HelloWorld.php 的文件，写入如下代码：<?phpdeclare(strict_types=1);namespace ExampleApp;class HelloWorld{public function announce(): void { echo 'Hello, autoloaded world!'; }}现在到 public/index.php 里面用  HelloWorld 类的 announce 方法替换掉 echo 语句。// ...require_once dirname(__DIR__) . '/vendor/autoload.php';$helloWorld = new \ExampleApp\HelloWorld();$helloWorld->announce();刷新浏览器查看新的信息！什么是依赖注入？依赖注入是一种编程技术，每个依赖项都供给它需要的对象，而不是在对象外获得所需的信息或功能。举个例子，假设应用中的类方法需要从数据库中读取。为此，你需要一个数据库连接。常用的技术就是创建一个全局可见的新连接。class AwesomeClass{public function doSomethingAwesome() { $dbConnection = return new \PDO( "{$_ENV['type']}:host={$_ENV['host']};dbname={$_ENV['name']}", $_ENV['user'], $_ENV['pass'] ); // Make magic happen with $dbConnection }}但是这样做显得很乱，它把一个并非属于这里的职责置于此地 --- 创建一个 数据库连接对象 ， 检查凭证 ， 还有 处理一些连接失败的问题 --- 它会导致应用中出现 大量  重复代码。如果你尝试对这个类进行单元测试，会发现根本不可行。这个类和应用环境以及数据库高度耦合。相反，为何不一开始就搞清楚你的类需要什么？我们只需要首先将 “PDO” 对象注入该类即可。class AwesomeClass{private $dbConnection; public function __construct(\PDO $dbConnection) { $this->dbConnection = $dbConnection; } public function doSomethingAwesome() { // Make magic happen with $this->dbConnection }}这样更简洁清晰易懂，且更不易产生 Bug。通过类型提示和依赖注入，该方法可以清楚准确地声明它要做的事情，而无需依赖外部调用去获取。在做单元测试的时候，我们可以很好地模拟数据库连接，并将其传入使用。依赖注入容器 是一个工具，你可以围绕整个应用程序来处理创建和注入这些依赖关系。容器并不需要能够使用依赖注入技术，但随着应用程序的增长并变得更加复杂，它将大有裨益。我们将使用 PHP 中最受欢迎的 DI 容器之一：名副其实的 PHP-DI。（值得推荐的是它文档中的 依赖注入另解 可能会对读者有所帮助）依赖注入容器现在我们已经安装了 Composer ，那么安装 PHP-DI 就轻而易举了，我们继续回到命令行来搞定它。composer require php-di/php-di修改 public/index.php 用来配置和构建容器。// ...require_once dirname(__DIR__) . '/vendor/autoload.php';$containerBuilder = new \DI\ContainerBuilder();$containerBuilder->useAutowiring(false);$containerBuilder->useAnnotations(false);$containerBuilder->addDefinitions([\ExampleApp\HelloWorld::class => \DI\create(\ExampleApp\HelloWorld::class)]);$container = $containerBuilder->build();$helloWorld = $container->get(\ExampleApp\HelloWorld::class);$helloWorld->announce();没啥大不了的。它仍是一个单文件的简单示例，你很容易能看清它是怎么运行的。迄今为止，我们只是在 配置容器 ，所以我们必须 显式地声明依赖关系 （而不是使用 自动装配 或 注解），并且从容器中检索 HelloWorld 对象。小贴士：自动装配在你开始构建应用程序的时候是一个很不错的特性，但是它隐藏了依赖关系，难以维护。 很有可能在接下里的岁月里， 另一个开发者在不知情的状况下引入了一个新库，然后就造就了多个库实现一个单接口的局面，这将会破坏自动装配，导致一系列让接手者很容易忽视的的不可见的问题。尽量 引入命名空间，可以增加代码的可读性。<?phpdeclare(strict_types=1);use DI\ContainerBuilder;use ExampleApp\HelloWorld;use function DI\create;require_once dirname(__DIR__) . '/vendor/autoload.php';$containerBuilder = new ContainerBuilder();$containerBuilder->useAutowiring(false);$containerBuilder->useAnnotations(false);$containerBuilder->addDefinitions([HelloWorld::class => create(HelloWorld::class)]);$container = $containerBuilder->build();$helloWorld = $container->get(HelloWorld::class);$helloWorld->announce();现在看来，我们好像是把以前已经做过的事情再拿出来小题大做。毋需烦心，当我们添加其他工具来帮助我们引导请求时，容器就有用武之地了。它会在适当的时机下按需加载正确的类。中间件如果把你的应用想象成一个洋葱，请求从外部进入，到达洋葱中心，最后变成响应返回出去。那么中间件就是洋葱的每一层。它接收请求并且可以处理请求。要么把请求传递到更里层，要么向更外层返回一个响应（如果中间件正在检查请求不满足的特定条件，比如请求一个不存在的路由，则可能发生这种情况）。如果请求通过了所有的层，那么程序就会开始处理它并把它转换为响应，中间件接收到响应的顺序与接收到请求的顺序相反，并且也能对响应做修改，然后再把它传递给下一个中间件。下面是一些中间件用例的闪光点：在开发环境中调试问题在生产环境中优雅的处理异常对传入的请求进行频率限制对请求传入的不支持资源类型做出响应处理跨域资源共享（CORS）将请求路由到正确的处理类那么中间件是实现这些功能的唯一方式吗？当然不是。但是中间件的实现使得你对请求 / 响应这个生命周期的理解更清晰。这也意味着你调试起来更简单，开发起来更快速。我们将从上面列出的最后一条用例，也就是路由，当中获益。路由路由依靠传入的请求信息来确定应当由哪个类来处理它。（例如 URI  /products/purple-dress/medium 应该被  ProductDetails::class 类接收处理，同时 purple-dress 和 medium 作为参数传入）在范例应用中，我们将使用流行的 FastRoute 路由，基于 PSR-15 兼容的中间件实现。中间件调度器为了让我们的应用可以和 FastRoute 中间件 --- 以及我们安装的其他中间件协同工作 --- 我们需要一个中间件调度器。PSR-15 是为中间件和调度器定义接口的中间件标准（在规范中又称 “请求处理器”），它允许各式各样的中间件和调度器互相交互。我们只需选择兼容 PSR-15 的调度器，这样就可以确保它能和任何兼容 PSR-15 的中间件协同工作。我们先安装一个 Relay 作为调度器。composer require relay/relay:2.x@dev而且根据 PSR-15 的中间件标准要求实现可传递 兼容 PSR-7 的 HTTP 消息 , 我们使用 Zend Diactoros 作为 PSR-7 的实现。composer require zendframework/zend-diactoros我们用 Relay 去接收中间件。// ...use DI\ContainerBuilder;use ExampleApp\HelloWorld;use Relay\Relay;use Zend\Diactoros\ServerRequestFactory;use function DI\create;// ...$container = $containerBuilder->build();$middlewareQueue = [];$requestHandler = new Relay($middlewareQueue);$requestHandler->handle(ServerRequestFactory::fromGlobals());我们在第 16 行使用 ServerRequestFactory::fromGlobals() 把 创建新请求的必要信息合并起来 然后把它传给 Relay。这正是 Request 进入我们中间件堆栈的起点。现在我们继续添加 FastRoute 和请求处理器中间件。（FastRoute 确定请求是否合法，究竟能否被应用程序处理，然后请求处理器发送 Request 到路由配置表中已注册过的相应处理程序中）composer require middlewares/fast-route middlewares/request-handler然后我们给 Hello, world! 处理类定义一个路由。我们在此使用 /hello 路由来展示基本 URI 之外的路由。// ...use DI\ContainerBuilder;use ExampleApp\HelloWorld;use FastRoute\RouteCollector;use Middlewares\FastRoute;use Middlewares\RequestHandler;use Relay\Relay;use Zend\Diactoros\ServerRequestFactory;use function DI\create;use function FastRoute\simpleDispatcher;// ...$container = $containerBuilder->build();$routes = simpleDispatcher(function (RouteCollector $r) {$r->get('/hello', HelloWorld::class);});$middlewareQueue[] = new FastRoute($routes);$middlewareQueue[] = new RequestHandler();$requestHandler = new Relay($middlewareQueue);$requestHandler->handle(ServerRequestFactory::fromGlobals());为了能运行，你还需要修改 HelloWorld 使其成为一个可调用的类， 也就是说 这里类可以像函数一样被随意调用。// ...class HelloWorld{public function __invoke(): void { echo 'Hello, autoloaded world!'; exit; }}（注意在魔术方法 __invoke() 中加入 exit;。 我们只需 1 秒钟就能搞定 —— 只是不想让你遗漏这个事）现在打开 http://localhost:8080/hello ，开香槟吧！万能胶水睿智的读者可能很快看出，虽然我们仍旧囿于配置和构建 DI 容器的藩篱之中，容器现在实际上对我们毫无用处。调度器和中间件在没有它的情况下也一样运作。那它何时才能发挥威力？嗯，如果 --- 在实际应用程序中总是如此 ——HelloWorld 类具有依赖关系呢？我们来讲解一个简单的依赖关系，看看究竟发生了什么。// ...class HelloWorld{private $foo; public function __construct(string $foo) { $this->foo = $foo; } public function __invoke(): void { echo "Hello, {$this->foo} world!"; exit; }}刷新浏览器..WOW！看下这个 ArgumentCountError.发生这种情况是因为 HelloWorld 类在构造的时候需要注入一个字符串才能运行，在此之前它只能等着。 这 正是容器要帮你解决的痛点。我们在容器中定义该依赖关系，然后将容器传给 RequestHandler 去 解决这个问题。// ...use Zend\Diactoros\ServerRequestFactory;use function DI\create;use function DI\get;use function FastRoute\simpleDispatcher;// ...$containerBuilder->addDefinitions([HelloWorld::class => create(HelloWorld::class) ->constructor(get('Foo')), 'Foo' => 'bar']);$container = $containerBuilder->build();// ...$middlewareQueue[] = new FastRoute($routes);$middlewareQueue[] = new RequestHandler($container);$requestHandler = new Relay($middlewareQueue);$requestHandler->handle(ServerRequestFactory::fromGlobals());嗟夫！当刷新浏览器的时候， "Hello, bar world!" 将映入你的眼帘！正确地发送响应是否还记得我之前提到过的位于 HelloWorld 类中的 exit 语句？当我们构建代码时，它可以让我们简单粗暴的获得响应，但是它绝非输出到浏览器的最佳选择。这种粗暴的做法给 HelloWorld 附加了额外的响应工作 —— 其实应该由其他类负责的 —— 它会过于复杂的发送所有的头部信息和 状态码，然后立刻退出了应用，使得 HelloWorld 之后 的中间件也无机会运行了。记住，每个中间件都有机会在 Request 进入我们应用时修改它，然后 (以相反的顺序) 在响应输出时修改响应。 除了 Request 的通用接口， PSR-7 同样也定义了另外一种 HTTP 消息结构，以辅助我们在应用运行周期的后半部分之用：Response。（如果你想真正了解这些细节，请阅读 HTTP 消息以及为何 PSR-7 请求和响应标准这么碉堡。）修改 HelloWorld 返回一个 Response。// ...namespace ExampleApp;use Psr\Http\Message\ResponseInterface;class HelloWorld{private $foo; private $response; public function __construct( string $foo, ResponseInterface $response ) { $this->foo = $foo; $this->response = $response; } public function __invoke(): ResponseInterface { $response = $this->response->withHeader('Content-Type', 'text/html'); $response->getBody() ->write("<html><head></head><body>Hello, {$this->foo} world!</body></html>"); return $response; }}然后修改容器给 HelloWorld 提供一个新的 Response 对象。// ...use Middlewares\RequestHandler;use Relay\Relay;use Zend\Diactoros\Response;use Zend\Diactoros\ServerRequestFactory;use function DI\create;// ...$containerBuilder->addDefinitions([HelloWorld::class => create(HelloWorld::class) ->constructor(get('Foo'), get('Response')), 'Foo' => 'bar', 'Response' => function() { return new Response(); },]);$container = $containerBuilder->build();// ...如果你现在刷新页面，会发现一片空白。我们的应用正在从中间件调度器返回正确的 Response 对象，但是... 肿么回事？它根本啥都没干，就这么回事。我们还需要一件东西来包装下：发射器。发射器位于应用程序和 Web 服务器（Apache，nginx 等）之间，将响应发送给发起请求的客户端。它实际上拿到了 Response 对象并将其转化为 服务端 API 可理解的信息。喜大普奔！ 我们已经用来封装请求的 Zend Diactoros 包同样也内置了发送 PSR-7 响应的发射器。值得注意的是，为了举例，我们只是对发射器的使用小试牛刀。虽然它们可能会更复杂点，真正的应用应该配置成自动化的流式发射器用来应对大量下载的情况， Zend 博客展示了如何实现它。修改 public/index.php ，用来从调度器那里接收 Response ，然后传给发射器。// ...use Relay\Relay;use Zend\Diactoros\Response;use Zend\Diactoros\Response\SapiEmitter;use Zend\Diactoros\ServerRequestFactory;use function DI\create;// ...$requestHandler = new Relay($middlewareQueue);$response = $requestHandler->handle(ServerRequestFactory::fromGlobals());$emitter = new SapiEmitter();return $emitter->emit($response);刷新浏览器，业务恢复了！这次我们用了一种更健壮的方式来处理响应。以上代码 return 那一行是我们应用中请求 / 响应周期结束的地方，同时也是 web 服务器接管的地方。总结现在你已经获得了现代化的 PHP 代码。 仅仅 44 行代码，在几个被广泛使用，经过全面测试和拥有可靠互操作性的组件的帮助下，我们就完成了一个现代化 PHP 程序的引导。它兼容 PSR-4， PSR-7，PSR-11 以及 PSR-15，这意味着你可以使用自己选择的其他任一供应商对这些标准的实现，来构建自己的 HTTP 消息， DI 容器，中间件，还有中间件调度器。我们深入理解了我们决策背后使用的技术和原理，但我更希望你能明白，在没有框架的情况下，引导一个新的程序是多么简单的一件事。或许更重要的是，我希望在有必要的时候你能更好的把这些技术运用到已有的项目中去。你可以在 这个例子的 GitHub 仓库 上免费 fork 和下载它。如果你正在寻找更高质量的解耦软件包资源，我衷心推荐你看看 Aura， 了不起的软件包联盟， Symfony 组件， Zend Framework 组件，Paragon 计划的聚焦安全的库， 还有这个 关于 PSR-15 中间件的清单.如果你想把这个例子的代码用到生产环境中， 你可能需要把路由和 容器定义 分离到它们各自的文件里面，以便将来项目复杂度提升的时候更好维护。我也建议 实现 EmitterStack 来更好的处理文件下载以及其他的大量响应。如果有任何问题，疑惑或者建议，请 给我留言。

PHP 进阶之路 - 亿级 pv 网站架构实战之性能优化 PHP 进阶之路 - 亿级 pv 网站架构实战之性能压榨缘起PV和PU（数据分析—业务指标）PV即访问次数——用户每访问一次可以看作一次PV。PU即访问人数——在同一天内，一个用户无论访问了多少次都算一个访客。通过PV和PU可以分析出用户喜欢产品哪个功能，不喜欢哪个功能，从而根据用户行为来优化产品。为什么过早的优化是万恶之源?在进行优化之前，应该先测试代码的性能，确定是否存在性能问题。同时，也应该优先考虑代码的可读性、可维护性和可扩展性，避免过度优化。使用XHProf查找PHP性能瓶颈XHProf是facebook 开发的一个测试php性能的扩展，本文记录了在PHP应用中使用XHProf对PHP进行性能优化，查找性能瓶颈的方法。性能优化的原则性能优化是建立在对业务的理解之上的性能优化与架构、业务相辅相成、密不可分的性能优化的引入我们先看一张简单的 web 架构图从上到下从用户的浏览器到最后的数据库，那么我们说先前端的优化。前端优化雅虎军规：http://www.cnblogs.com/paul-3... 减少 http 请求数图片、css、script等等这些都会增加http请求数，减少这些元素的数量就能减少响应时间。把多个JS、CSS在可能的情况下写进一个文件，页面里直接写入图片也是不好的做法，应该写进CSS里，小图拼合后利用 background 来定位。现在很多 icon 都是直接做成字体，矢量高清，也减少网络请求数现在的前端框架都会通过组件的方式开发，最后打包生成一个 js 或者 两个 js 文件 + 一个 css 或者两个 css 文件。利用浏览器缓存expires,cache-control,last-modified,etag http://blog.csdn.net/eroswang... 防止缓存，比如资源更新了，原来的做法是?v=xxxx 现在前端的打包工作可以能会生成 /v1.2.0/xxx.js使用分布式存储前端资源接地气利用 cdn 存储前端资源多域名访问资源原因一：浏览器对同一域名的并行请求数有上限，多个域名则支持更多并行请求原因二：使用同一域名的时候无用的 cookie 简直是噩梦数据压缩开启gzip前端资源本身的压缩，js/css 打包编译（去掉空格，语意简化）图片资源的压缩等。优化首屏展示速度资源的按需加载，延时加载  https://blog.csdn.net/m0_64346035/article/details/125131432图片的懒加载，淘宝的商品介绍太多图，用户点击进来又有多少人一直往下看图的呢？ 前端懒加载nginx 优化分为下面三个部分来nginx 本身配置的优化worker_processes auto 设置多少子进程worker_cpu_affinity 亲缘性绑定worker_rlimit_nofile 65535 worker 进程打开的文件描述符的最大数worker_connections 65535 子进程最多处理的连接数epoll 多路复用sendfile on 是对文件I/O的系统调用的一个优化，系统api如果是反向代理web服务器，需要配置fastcgi相关的参数数据返回开启gzip压缩静态资源使用 http 缓存协议开启长连接 keepalive_timeout        fastcgi_connect_timeout 300;         fastcgi_send_timeout 300;         fastcgi_read_timeout 300;         fastcgi_buffer_size 64k;         fastcgi_buffers 4 64k;         fastcgi_busy_buffers_size 128k;         fastcgi_temp_file_write_size 256k;        gzip on;         gzip_min_length  1k;         gzip_buffers     4 16k;         gzip_http_version 1.0;         gzip_comp_level 2;         gzip_types       text/plain application/x-javascript text/css application/xml text/javascript application/json;         gzip_vary on;         gzip_proxied        expired no-cache no-store private auth;         gzip_disable        "MSIE \[1-6\]\\.";        location ~ .*\\.(gif|jpg|jpeg|png|bmp|swf)$             {                 expires      30d;             }worker_connections和worker_rlimit_nofile有什么区别tcp/ip 网络协议配置的优化/proc/sys/net/ipv4/tcp_tw_recycle 1 开启TCP连接中TIME-WAIT sockets的快速回收,保证tcp_timestamps = 1/proc/sys/net/ipv4/tcp_tw_reuse 1 允许将TIME-WAIT sockets重新用于新的TCP连接/proc/sys/net/ipv4/tcp_syncookies 0 是否需要关闭洪水抵御 看自己业务，比如秒杀，肯定需要关闭了/proc/sys/net/ipv4/tcp_max_tw_buckets 180000 否则经常出现 time wait bucket table overflowtcp_nodelay on 小文件快速返回，我之前通过网络挂载磁盘出现找不到的情况tcp_nopush ontcp_tw_recycle 快速回收可能导致丢包的问题 https://www.im050.com/posts/435linux 系统的优化除了上面的网络协议配置也是在系统基础之外，为了配合nginx自己里面的设定需要做如下修改/proc/sys/net/core/somaxconn 65535ulimit -a 65535Nginx配置性能优化的方法php 优化升级到 php7注意有很多函数和扩展被废弃，比如mysql相关的，有风险，做好测试再切换。opcode 缓存php 5.5 之后好像就内置了吧，需要在php.ini里添加如下配置opcache.revalidate_freq=60 opcache.validate_timestamps=1 opcache.max_accelerated_files=1000 opcache.memory_consumption=512 opcache.interned_strings_buffer=16 opcache.fast_shutdown=1opcache.revalidate_freq这个选项用于设置缓存的过期时间（单位是秒），当这个时间达到后，opcache会检查你的代码是否改变，如果改变了PHP会重新编译它，生成新的opcode，并且更新缓存。opcache.validate_timestamps当这个选项被启用（设置为1），PHP会在opcache.revalidate_freq设置的时间到达后检测文件的时间戳（timestamp）。opcache.max_accelerated_files这个选项用于控制内存中最多可以缓存多少个PHP文件。opcache.memory_consumption你可以通过调用opcachegetstatus()来获取opcache使用的内存的总量opcache.interned_strings_buffer字符串opcache的复用，单位为MBopcache.fast_shutdown=1开启快速停止续发事件，依赖于Zend引擎的内存管理模块php7 hugepage 的使用Hugepage 的作用：间接提高虚拟地址和内存地址转换过程中查表的TLB缓存命中率opcache.huge_code_pages=1鸟哥博客详细介绍：http://www.laruence.com/2015/...代码伪编译以thinkphp为例，它会把框架基础组件（必须用到的组件）合并压缩到一个文件中，不仅减少了文件目录查找，文件打开的系统调用。 通过stracephp-fpm子进程，可以清楚系统调用的过程，在我上面例子中有打开一个文件有12次系统调用（只是举例，我这里相对路径设置的原因导致多了两次文件查找）。如果有10个文件，那就是120次，优化的效果可能不是那么明显，但是这是一种思路。 顺便说下 set_include_path能不用就不要用，上面的demo的截图里面找不到目录就是证明。模板编译模板把它们自定义的语法，最后转换成php语法，这样方便解析。而不是每次都解析一遍。xhprof 查找性能瓶颈xhprof 查找性能瓶颈业务优化非侵入式扩展开发比如原来有一个model，叫问答，现在需要开发一个有奖问答，需要支持话题打赏，里面多了很多功能。这个时候应该利用面向对象的继承的特性。而不是做下面的开发<?php class AskModel {     public function detail($id){         $info = 从数据库查询到该问题的信息;         // 逻辑1                  // 逻辑2              } }<?php class AskModel {     public function detail($id){         $info = 从数据库查询到该问题的信息;         // 逻辑1         if($info\['type'\] == 2){             //...         }else{                      }                 // 逻辑2         if($info\['type'\] == 2){             //...         }else{                      }     } }这样逻辑多了，子类型多了，逻辑判断就非常重复，程序运行起来低效可能是一方面，更多的是不可维护性。业务和架构不分家，架构是建立在对业务的理解之上的。异步思想举例：处理邮件发送。gearman 图片裁剪。页面上 ajax 加载动态数据。图片的懒加载，双击图片看大图。sf 上通过websocket 通知你有新的消息，但是并没有告诉你有什消息，点击消息图标才会去异步请求具体的消息。这些都是异步的思想。能分步走就分步走，能不能请求的就不请求。静态化专题页面，比如秒杀页面，为了应对更大的流量、并发。而且更新起来也比较方便。业务解耦比如刚刚上面说的专题页面，还有必要走整个框架的一套流程吗？进来引用一大堆的文件，初始化一大堆的东西？是不是特别低效呢？所以需要业务解耦，专题页面如果真要框架（可以首次访问之后生成静态页面）也应该是足够轻量级的。不能与传统业务混为一谈。分布式以及 soa说业务优化，真的不得不提架构方面的东西，业务解耦之后，就有了分布式和soa。 说下 soa 自定义 socket 传输协议。 最重要的就是在自定义头里面强调body_len，注意设置为紧凑型，才能保证跨平台性Mysql 优化数据索引相关的文章网上很多了，不足的地方大家补充。表设计 - 拥抱 innodb现在大多数情况都会使用innodb类型了。具体原因是 mysql 专家给的意见。 我自己对 mysql 的优化不了解，每一个细分领域都是一片汪洋，每个人的时间精力是有限的，所以大家也不用什么都非要深入去研究，往往是一些计算机基础更为重要。 参考这份ppt MySQL秘籍.pdf表设计 - 主键索引innodb 需要一个主键，主键不要有业务用途，不要修改主键。主键最好保持顺序递增，随机主键会导致聚簇索引树频繁分裂，随机I/O增多，数据离散，性能下降。举例： 之前项目里有些索引是article_id + tag_id 联合做的主键，那么这种情况下，就是业务了属性了。主键也不是顺序递增，每插入新的数据都有可能导致很大的索引变动（了解下数据库b+索引的原理）表设计 - 字段选择能选短整型，不选长整型。比如一篇文章的状态值，不可能有超过100种吧，不过怎么扩展，没必要用int了。能选 char 就避免 varchar，比如图片资源都有一个hashcode，固定长度20位，那么就可以选char了。当使用 varchar 的时候，长度够用就行，不要滥用。大文本单独分离，比如文章的详情，单独出一张表。其他基本信息放在一张表里，然后关联起来。冗余字段的使用，比如文章的详情字段，增加一个文章markdown解析之后的字段。索引优化大多数情况下，索引扫描要比全表扫描更快，性能更好。但也不是绝对的，比如需要查找的数据占了整个数据表的很大比例，反而使用索引更慢了。没有索引的更新，可能会导致全表数据都被锁住。所以更新的时候要根据索引来做。联合索引的使用explain 的使用联合索引“最左前缀”，查询优化器还会帮你调整条件表达式的顺序，以匹配组合索引的要求。CREATE TABLE `test` (   `id` int(11) unsigned NOT NULL AUTO_INCREMENT,   `a` int(10) unsigned NOT NULL,   `b` int(10) unsigned NOT NULL,   `c` int(10) unsigned NOT NULL,  PRIMARY KEY (`id`),   KEY `index_abc` (`a`,`b`,`c`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;能使用到索引explain select * from test where a=1; explain select * from test where a=1 and b=2; explain select * from test where a=1 and b=2 and c=3; explain select * from test where a=1 and b in (2,3) and c=3; explain select * from test where a=1 and b=2 order by c desc;不能使用索引explain select * from test where a=1 and b in (2,3) order by c desc; explain select * from test where b=2;explain 搜到一篇不错的: http://blog.csdn.net/woshiqjs... 很重要的参数type,key,extratype 最常见的system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALLextra如果有Using filesort或者Using temporary的话,就必须要优化了收集慢查询my.ini 配置里增加long_query_time=2 log-slow-queries=/data/var/mysql_slow.log使用 nosqlredis 丰富的数据类型，非常适合配合mysql 做一些关系型的查询。比如一个非常复杂的查询列表可以将其插入zset 做排序列表，然后具体的信息，通过zset里面的纸去mysql 里面去查询。缓存优化多级缓存请求内缓存static 变量存储，比如朋友圈信息流，在一次性获取20条信息的时候，有可能，点赞的人里面20条里面有30个人是重复的，他们点赞你的a图片也点赞了你的b图片，所以这时，如果能使用static数组来存放这些用户的基本信息就高效了些。本地缓存请求结束了，下拉更新朋友圈，里面又出现了上面的同样的好友，还得重新请求一次。所以本地常驻内存的缓存就更高效了。分布式缓存在A服务器上已经查询过了，在下拉更新的时候被分配到B服务器上了，难道同样的数据再查一次再存到B服务器的本地缓存里面吗，弄一个分布式缓存吧，这样防止了重复查询。但是多了网络请求这一步。很多时候是三者共存的。避免缓存的滥用案例分析用户积分更新比如用户的基本信息和积分混在一起，当用户登录的时候赠送积分。则需要更新用户的积分，这个时候更新整个用户的基本信息缓存么？所以这里也可以运用下面 hashes 分片的原则去更新礼物和主题绑定缓存为了取数据方便把多个数据源混合缓存了，这种情况，相比大家可能都见过，这是灾难性的设计。{id:x,title:x,gift:{         id:x,         name:x,         img:x,     }}如果需要更新礼物的图片，那么所有用到过这个礼物的话题的缓存都要更新。redis 优化多实例化，更高效地利用服务器 cpu内存优化，官方意见 https://redis.io/topics/memor... 有点老尽可能的使用 hashes ，时间复杂度低，查询效率高。同时还节约内存。Instagram 最开始用string来存图片id=>uid的关系数据，用了21g，后来改为水平分割，图片id 1000 取模，然后将分片的数据存在一个hashse 里面，这样最后的内容减少了5g，四分之一基本上。每一段使用一个Hash结构存储，由于Hash结构会在单个Hash元素在不足一定数量时进行压缩存储，所以可以大量节约内存。这一点在String结构里是不存在的。而这个一定数量是由配置文件中的hash-zipmap-max-entries参数来控制的。服务器认知的提升下面的内容，只能是让大家有一个大概的认识，了解一个优化的方向，具体的内容需要系统学习很多很多的知识。多进程的优势多进程有利于 CPU 计算和 I/O 操作的重叠利用。一个进程消耗的绝大部分时间都是在磁盘I/O和网络I/O中。 如果是单进程时cpu大量的时间都在等待I/O，所以我们需要使用多进程。减少上下文切换为了让所有的进程轮流使用系统资源，进程调度器在必要的时候挂起正在运行的进程，同时恢复以前挂起的某个进程。这个就是我们常说的“上下文切换”。无限制增加进程数，则会增多 cpu 在各个进程间切换的次数。 如果我们希望服务器支持较大的并发数，那么久要尽量减少上下文切换的次数，比如在nginx服务上nginx的子进程数不要超过cpu的核数。 我们可以在压测的时候通过vmstat,nmon来监控系统上下文切换的次数。IOwait 不一定是 I/O 繁忙# top top - 09:40:40 up 565 days,  5:47,  2 users,  load average: 0.03, 0.03, 0.00 Tasks: 121 total,   2 running, 119 sleeping,   0 stopped,   0 zombie Cpu(s):  8.6%us,  0.3%sy,  0.0%ni, 90.7%id,  0.2%wa,  0.0%hi,  0.2%si,  0.0%st一般情况下IOwait代表I/O操作的时间占（I/O操作的时间 + I/O和CPU时间）的比例。 但是也时候也不准，比如nginx来作为web服务器，当我们开启很多nginx子进程，IOwait会很高，当再减少进程数到cpu核数附近时，IOwait会减少，监控网络流量会发现也增加。多路复用 I/O 的使用只要是提供socket服务，就可以利用多路复用 I/O 模型。减少系统调用strace 非常方便统计系统调用# strace -c -p 23374Process 23374 attached - interrupt to quit ^CProcess 23374 detached % time     seconds  usecs/call     calls    errors syscall ------ ----------- ----------- --------- --------- ----------------  30.68    0.000166           0       648           poll  12.01    0.000065           0       228           munmap  11.65    0.000063           0       228           mmap  10.54    0.000057           0       660           recvfrom  10.35    0.000056           0       708           fstat   7.76    0.000042           0       252           open   6.10    0.000033           1        36           write   5.73    0.000031           0        72        24 access   5.18    0.000028           0        72           read   0.00    0.000000           0       276           close   0.00    0.000000           0        13        13 stat   0.00    0.000000           0       269       240 lstat   0.00    0.000000           0        12           rt_sigaction   0.00    0.000000           0        12           rt_sigprocmask   0.00    0.000000           0        12           pwrite   0.00    0.000000           0        48           setitimer   0.00    0.000000           0        12           socket   0.00    0.000000           0        12           connect   0.00    0.000000           0        12           accept   0.00    0.000000           0       168           sendto   0.00    0.000000           0        12           shutdown   0.00    0.000000           0        48           fcntl   0.00    0.000000           0        12           flock   0.00    0.000000           0       156           getcwd   0.00    0.000000           0        24           chdir   0.00    0.000000           0        24           times   0.00    0.000000           0        12           getuid ------ ----------- ----------- --------- --------- ---------------- 100.00    0.000541                  4038       277 total通过strace查看“系统调用时间”和“调用次数”来定位问题strace：跟踪进程的系统调用 、ltrace：跟踪进程调用库函数自己构建web服务器要想理解web服务器优化的原理，最好的办法是了解它的来龙去脉，实践就是最好的方式，我分为以下几个步骤：用 PHP 来实现一个动态 Web 服务器 简单静态 web 服务器（循环服务器）的实现 多进程并发的面向连接 Web 服务器的实践简单静态 Select Web 服务器的实现I/O 多路复用上面是我的学习笔记，图片资源丢失了，大家可以根据相关关键词去搜搜相关的文章和书籍，更推荐大家去看书。

PHP调试的强悍利器之PHPDBG PHP调试的强悍利器之PHPDBGPHPDBG是一个PHP的SAPI模块，可以在不用修改代码和不影响性能的情况下控制PHP的运行环境。PHPDBG的目标是成为一个轻量级、强大、易用的PHP调试平台。可以在PHP5.4和之上版本中使用。在php5.6和之上版本将内部集成。主要功能：? 单步调试? 灵活的下断点方式（类方法、函数、文件:行、内存地址、opcode）? 可直接调用php的eval? 可以查看当前执行的代码? 用户空间API（userland/user space）? 方便集成? 支持指定php配置文件? JIT全局变量? readline支持（可选），终端操作更方便? 远程debug，使用java GUI? 操作简便（具体看help）安装为了使用phpdgb，你首先需要下载一个php的源码包。然后下载phpdgb的源码包，并放在php源码包的sapi目录下。最后，你就可以执行命令安装了。编译安装示例如下：假设我们已经下载php的源码包，并放在了/home/php目录下。cd /home/php/sapi#git clone https://github.com/krakjoe/phpdbg#cd ../#./buildconf --force#./config.nice#make -j8#make install-phpdbg注意：1、如果你的php版本是php5.6或者更高的版本，phpdbg已经集成在php的代码包中，无需单独下载了。2、编译参数中记得要加 ?enable-phpdbg。3、编译时参数，?with-readline 可以选择性添加。如果不添加，phpdbg的history等功能无法使用。基本使用1、参数介绍phpdbg是php的一个sapi，它可以以命令行的方式调试php。常用参数如下：The following switches are implemented (just like cli SAPI):-n ignore php ini-c search for php ini in path-z load zend extension-d define php ini entryThe following switches change the default behaviour of phpdbg:-v disables quietness-s enabled stepping-e sets execution context-b boring ? disables use of colour on the console-I ignore .phpdbginit (default init file)-i override .phpgdbinit location (implies -I)-O set oplog output file-q do not print banner on startup-r jump straight to run-E enable step through eval()Note: passing -rr will cause phpdbg to quit after execution, rather than returning to the console2、常用功能之前我们介绍过gdb工具。其实phpdbg和gdb功能有些地方非常相似。如，可以设置断点，可以单步执行，等。只是他们调试的语言不一样，gdb侧重于调试c或者c++语言，而phpdbg侧重于调试php语言。下面我们将对phpdbg的一些常用调试功能做下介绍。要调试的代码如下：文件test_phpdbg_inc.php源代码如下：<?php function phpdbg_inc_func(){ echo "phpdbg_inc_func \n"; } ?>文件test_phpdgb.php的源代码如下：<?php include(dirname(__FILE__)."/test_phpdbg_inc.php"); class demo{public function __construct(){ echo __METHOD__.":".__LINE__."\n"; } public function func($param){ $param++; echo "method func $param\n"; } public function __destruct(){ echo __METHOD__.":".__LINE__."\n"; }} function func(){ $param = "ali"; $param = $param + "baba"; echo "function func $param\n"; }$demo = new demo(); $demo->func(1); func(); phpdbg_inc_func();?>3、启动phpdbgphpdbg安装成功后，会在安装目录的bin目录下。进入bin目录，直接输入phpdbg即可。如下：phpdeg[Welcome to phpdbg, the interactive PHP debugger, v0.4.0]To get help using phpdbg type "help" and press enter[Please report bugs to http://github.com/krakjoe/phpdbg/issues]prompt>要想加载要调试的php脚本，只需要执行exec命令即可。如下：phpdbg......prompt> exec ./test_phpdbg.php当然我们也可以在启动phpdbg的时候，指定e参数。如下：phpdbg -e ./test_phpdbg.php4、查看帮助信息如果你之前使用过其他的调试工具，你会发现phpdbg和他们比较相似。但是，你使用初期，还是会经常需要获取帮助信息。通过help命令我们可以获取帮助信息。......prompt> helpphpdbg is a lightweight, powerful and easy to use debugging platform for PHP5.4+It supports the following commands:Information list list PHP source......5、设置断点设置断点的命令和gdb一样。都是break，简写形式为b。不过具体的命令参数还是有所差异的。和gdb的断点命令相同之处，它们都可以“按文件名:行号” 或者 行号的方式设置断点。除此之外，phpdbg还提供了一些针对php特有的设置断点的方式。如，根据opline设置断点，根据opcode设置断点等。众所周知，php代码最终是解析成opcode，然后由php内核一条条执行。一条php语句，可能会解析成多条opcode。如果可以按opcode设置断点，我们就可以更精确的跟踪程序执行过程。下面我们来看看phapdbg设置断点的具体示例。按opline设置断点：这里所说的opline，就是以方法入口作为起点，当前代码的行号。如test_phpdgb.php文件中，第18行的代码“$param = $param + “baba”;”的opline就是 2。......prompt> b func#2prompt> rdemo::__construct:5method func 2[Breakpoint #0 resolved at func#2 (opline 0x7f5b230a2e38)][Breakpoint #0 resolved at func#2 (opline 0x7f5b230a2e38)][Breakpoint #0 resolved at func#2 (opline 0x7f5b230a2e38)][Breakpoint #0 in func()#2 at ./test_phpdbg.php:18, hits: 1]00018: $param = $param + "baba"; 00019: echo "function func $param\n";; 00020: }......6、查看断点和gdb一样，phpdbg也是使用info break命令查看断点。示例如下：....prompt> info break------------------------------------------------File Breakpoints:#1 /home/hailong.xhl/test_phpdbg.php:10------------------------------------------------Opline Breakpoints:#0 7ff3219e1df0 (function breakpoint)------------------------------------------------Function opline Breakpoints:#0 func opline 2....通过上面的显示，我们可以知道。info break的显示结果中会把断点的类型也给显示出来。#后面的数字是断点号。我们可以根据断点号删除断点。7、删除断点和gdb命令不一样。phpdbg的删除断点不是delete命令，而是break del 命令。示例如下：......prompt> break del 1[Deleted breakpoint #1]prompt>......break del 后面的数字1就是断点号。8、查看代码phpdbg查看代码的命令也是list。但是和gdb相比，使用的方式更多样一些。显示指定函数的代码：......prompt> l f func 00017: $param = "ali"; 00018: $param = $param + "baba"; 00019: echo "function func $param\n";; 00020: } 00021:prompt>......单步执行phpdbg的单步执行只有一个命令 step。和gdb的step命令差不多。都是一行一行的执行代码。注意，phpdbg是没有next命令的。....prompt> sBreakpoint #0 resolved at func#2 (opline 0x152ba40)00019: echo "function func $param\n";; 00020: } 00021:....继续执行和gdb一样，phpdbg的继续执行命令也是continue，简写形式为c。执行php代码这个是phpdbg的一个特色。可以在调试的过程中使用ev命令执行任意的php代码。如：......prompt> ev $var = "val";valprompt> ev var_dump($var);string(3) "val"......可以通过这种方式，在调试过程中动态的修改变量值，查看执行效果。

PHP中的协程 PHP中的协程之前学习Lua的时候第一次接触到了协程(coroutine)的概念。而PHP5.5版本中也加入了协程的概念，从此PHP编程又有了新的思路和玩法。这里学习一下PHP中协程的相关概念的使用方法。分成上下两篇文章吧，这篇主要讲一下基础概念。协程是什么？在以前的Lua学习笔记三中可以看到，协程与多线程的比较，有自己的堆栈、局部变量、指令指针等，但是协程本身与其他协程共享全局变量。主要不同在于，多处理器下，多线程可以真实的同时运行多个线程。而协程任意时刻只能有一个在真实运行，并且只有在明确要求被挂起时才会挂起。PHP中协程如何理解？这里引用知乎赵老师的答案，说的比较好理解。具体来说，一个包含yeild的php函数，就是协程，他有阶段性的结算值 yield $var， 但是代码并不返回，php的调度者接到这个值后，喂给一个generator，generator是个实现了iterator接口的+和协程通讯接口（比如send方法）的实例，所以可以用在for循环里（另个接口负责和协程通讯）。那么generator收到了这个协程的阶段性的值后，他喂给for循环，等for循环下一次循环的时候，他又启动这个协程，协程从上次中断的点继续执行，继续计算，继续yeild值给generator，generator喂for循环，继续循环，直到协程执行完毕。相关函数final class Generator implements Iterator {public function rewind(); // 返回到迭代器的第一个元素。 public function valid(); // 返回false如果迭代器已经关闭，否则返回true public function current(); // 返回当前yield值. public function key(); // 返回当前yield键名. public function next(); // 恢复生成器的执行。 public function PS_UNRESERVE_PREFIX_throw(Exception $exception) {};//抛出异常 public function send($value); // 将传入的值作为yield表达式的结果并且恢复发生器的执行。}简单例子简单的迭代器给foreach使用function my_range($start, $end, $step = 1) {for ($i = $start; $i <= $end; $i += $step) { yield $i; }}foreach (my_range(1, 5) as $num) {echo $num;}//output 12345带send可以交互的例子function gen() {$ret = (yield 'a'); echo $ret; $ret = (yield 'b'); echo $ret;}$gen = gen();$ret = $gen->current();echo $ret;$ret = $gen->send("c");echo $ret;$ret = $gen->send("d");echo $ret;//output acbd带抛出异常的例子function gen() {try{ $ret = (yield 'a'); echo $ret; $ret = (yield 'b'); echo $ret; } catch (Exception $ex) { echo $ex->getMessage(); }}$gen = gen();$ret = $gen->current();echo $ret;$ret = $gen->send("c");echo $ret;$ret = $gen->throw(new Exception("d"));var_dump($ret);//output acbdNULL那么能用来干什么呢？我们来看看，协程可以自己主动出让执行权，把不需要抢占的操作时间(比如socket等待链接)让出来，并且可以和调用方通过yield的方式传递信息。显而易见，他可以用来做多任务调度！PHP中协程实现多任务调度，鸟哥有一篇翻译的文章里有讲解，网上能找到的大部分资料，都跟这篇相关。但是至少在我看来，理解起来还是蛮复杂的。这里针对那篇文章的前半部分做一个笔记，忽略后面关于独立堆栈协程的部分。function里使用yield关键字，将生成迭代器。这样调用functionName()时，其实得到的是一个迭代器对象，而并没有实际运行程序。为什么要走系统调用SystemCall这一层呢？模拟进程和系统会话的方式，控制权限。通过给yield表达式传递信息来与调度器通信，yield既是中断也是传递给调度器的方式。SystemCall 包含一个回调函数，他自己本身可以被执行。被执行时实际上是调用了这个回调函数，入参是某个task和调度器。SystemCall其实并没有其他作用，只是在协程函数里面跟在yield后面传给调度器来执行。注意SplQueue塞进去的对象其实是引用(PHP里对象入参都是引用，不只是SplQueue)！外面对象改了，里面也会变。为什么忽略协程堆栈？我打算在第二篇文章中，把有赞的zan framework里关于协程的部分抽出来，针对性的说一下包含子协程额多任务调度。当然主要想偷个懒。不过个人感觉zan框架里的协程部分，比之前说的那篇文章要好理解一些。上篇文章里提到PHP中协程的引入，可以使PHP编程有新的玩法，不在遵循原本顺序执行的思路，从而应对大访问量和并发操作。有赞的zan framework就是基于PHP协程的，提供最简单的方式开发面向C10K+的高并发HTTP服务或SOA服务。我并没有深入的学习这个框架，这里只打算把关于协程的部分抽出来学习一下。zan框架高并发设计思路粗看之下(不一定对哦)，框架应该是用swoole_server + 协程解决高并发访问。比如Web服务中，swoole的http_server只开启了少数的几个worker进程。我们知道，如果worker的onRequest里使用的是异步方法，则worker的响应是异步处理的，反之则是阻塞的。zan框架在worker进程中大量使用了PHP协程，所以一个worker进程可以响应很多并发的请求(但是本质上正在执行的只有一个)，这应该就是能过达到C10K+的原因吧。并且协程相对于回调的方式，在PHPer看来更容易接受吧。另外，框架设计里还使用了middleware、连接池、依赖注入等等比较现代的设计，感觉可以更深入的学习一下。一个类一个类来看我们把框架里关于协程的部分拆出来看，下面一个类一个类的分析。与鸟哥博客里那个文章的实现相比，有一些相同的地方，更多的是不同。比如那篇文章里，多个任务放到一个schedule里调度，对于后面的实现就比较繁琐。这里把框架里的代码抽出来，并进行了一定删减，去掉了与其他业务强相关的东西。比如Event、Context、Async等等。实际上Async用于处理MySQL查询的返回值的，框架内部将MySQL的具体操作类封装成了Async的子类，并且yield给调度器来用。Singal类Singal类里包含了系统调用所需的信号量。指明了协程在一轮运行之后应该处于的状态。class Signal{const TASK_SLEEP = 1; const TASK_AWAKE = 2; const TASK_CONTINUE = 3; const TASK_KILLED = 4; const TASK_RUNNING = 5; const TASK_WAIT = 6; const TASK_DONE = 7; public static function isSignal($signal) { if(!$signal) { return false; } if (!is_int($signal)) { return false; } if($signal < 1 ) { return false; } if($signal > 7) { return false; } return true; }}Task类Task包装了具体协程函数，并提供相应的get set方法。与网上流行的那篇文章(以下简称那文)不同的是，我们的scheduler是内置于Task里的，在run方法里实现具体的调度。这里我们省略了Context，并且让taskId自增。class Task{protected $taskId = 0; protected $parentId = 0; protected $coroutine = null; //这里忽略了context 保存的是当前http请求的相关信息，可以通过系统调用的方式操作 protected $context = null; protected $sendValue = null; protected $scheduler = null; protected $status = 0; public function __construct(Generator $coroutine, $taskId = 0, $parentId = 0) { $this->coroutine = $coroutine; if(isset($GLOBALS['stTaskId']) && $taskId == 0){ global $stTaskId; $taskId = $stTaskId ++; } $this->taskId = $taskId; $this->parentId = $parentId; $this->scheduler = new Scheduler($this); } /** * 静态方法调用 * @param $coroutine * @param int $taskId * @param int $parentId * @return Task */ public static function execute($coroutine, $taskId = 0, $parentId = 0) { if ($coroutine instanceof Generator) { if(isset($GLOBALS['stTaskId']) && $taskId == 0){ global $stTaskId; $taskId = $stTaskId ++; } $task = new Task($coroutine, $taskId, $parentId); $task->run(); return $task; } return $coroutine; } public function run() { while (true) { try { if ($this->status == Signal::TASK_KILLED){ $this->fireTaskDoneEvent(); break; } $this->status = $this->scheduler->schedule(); //以下几种状态表示信号量，实际上已经从while里跳出来了。如果需要继续的话，会在其他地方重启。 switch ($this->status) { case Signal::TASK_KILLED: case Signal::TASK_SLEEP: case Signal::TASK_WAIT: return null; case Signal::TASK_DONE: $this->fireTaskDoneEvent(); return null; } } catch (Exception $e) { $this->scheduler->throwException($e); } } } public function send($value) { $this->sendValue = $value; return $this->coroutine->send($value); } public function getTaskId() { return $this->taskId; } public function getContext() { return $this->context; } public function getSendValue() { return $this->sendValue; } public function getResult() { return $this->sendValue; } public function getStatus() { return $this->status; } public function setStatus($signal) { $this->status = $signal; } public function getCoroutine() { return $this->coroutine; } public function setCoroutine(Generator $coroutine) { $this->coroutine = $coroutine; } public function fireTaskDoneEvent() { echo "Task done $this->taskId\n"; }}Scheduler类scheduler类负责：获取Task里的协程函数跑完一轮的返回值根据返回值的类型采取不同的处理方式，如系统调用、子协程、普通yield值、检查协程栈等等。在子协程的调用过程中，负责父子协程的进栈出栈，yield值的传递等等。class Scheduler{private $task = null; private $stack = null; public function __construct(Task $task) { $this->task = $task; $this->stack = new SplStack(); } public function schedule() { $coroutine = $this->task->getCoroutine(); $value = $coroutine->current(); $signal = $this->handleSysCall($value); if ($signal !== null) return $signal; $signal = $this->handleCoroutine($value); if ($signal !== null) return $signal; $signal = $this->handleYieldValue($value); if ($signal !== null) return $signal; $signal = $this->handleTaskStack($value); if ($signal !== null) return $signal; $signal = $this->checkTaskDone($value); if ($signal !== null) return $signal; return Signal::TASK_DONE; } public function isStackEmpty() { return $this->stack->isEmpty(); } public function throwException($e, $isFirstCall = false) { if ($this->isStackEmpty()) { $this->task->getCoroutine()->throw($e); return; } try{ if ($isFirstCall) { $coroutine = $this->task->getCoroutine(); } else { $coroutine = $this->stack->pop(); } $this->task->setCoroutine($coroutine); $coroutine->throw($e); $this->task->run(); }catch (Exception $e){ $this->throwException($e); } } /** * 处理系统调用 * @param $value * @return mixed|null */ private function handleSysCall($value) { if (!($value instanceof SysCall) && !is_subclass_of($value, SysCall::class) ) { return null; } echo $this->task->getTaskId()."| SYSCALL\n"; //走系统调用 实际上因为__invoke 走的是 $value($this->task); $signal = call_user_func($value, $this->task); if (Signal::isSignal($signal)) { return $signal; } return null; } /** * 处理子协程 * @param $value * @return int|null */ private function handleCoroutine($value) { if (!($value instanceof Generator)) { return null; } echo $this->task->getTaskId()."| COROUTINE\n"; //获取当前的协程 入栈 $coroutine = $this->task->getCoroutine(); $this->stack->push($coroutine); //将新的协程设为当前的协程 $this->task->setCoroutine($value); return Signal::TASK_CONTINUE; } /** * 处理协程栈 * @param $value * @return int|null */ private function handleTaskStack($value) { //能够跑到这里说明当前协程已经跑完了 valid()==false了 需要看下栈里是否还有以前的协程 if ($this->isStackEmpty()) { return null; } echo $this->task->getTaskId()."| TASKSTACK\n"; //出栈 设置为当前运行的协程 $coroutine = $this->stack->pop(); $this->task->setCoroutine($coroutine); //这个sendvalue可能是从刚跑完的协程那里得到的 把它当做send值传给老协程 让他继续跑 $value = $this->task->getSendValue(); $this->task->send($value); return Signal::TASK_CONTINUE; } /** * 处理普通的yield值 * @param $value * @return int|null */ private function handleYieldValue($value) { $coroutine = $this->task->getCoroutine(); if (!$coroutine->valid()) { return null; }// if($this->task->getTaskId() == 2){//// }else{ echo $this->task->getTaskId()."| YIELD VALUE\n";// } //如果协程后面没有yield了 这里发出send以后valid就变成false了 并且current变成NULL $status = $this->task->send($value); return Signal::TASK_CONTINUE; } private function checkTaskDone($value) { $coroutine = $this->task->getCoroutine(); if ($coroutine->valid()) { return null; } echo $this->task->getTaskId()."| CHECKDONE\n"; return Signal::TASK_DONE; }}SysCall类与那文的思路相同，系统调用类一般作为yield后面跟着的值吐给外层的调用方来执行，并且可能返回响应的信号量，标识这个Task是继续运行还是进入等待状态中。不同的是这里的__invoke入参不需要Scheduler。class SysCall{protected $callback = null; public function __construct(\Closure $callback) { $this->callback = $callback; } public function __invoke(Task $task) { return call_user_func($this->callback, $task); }}组装起来！基本的组件就是上面的几个类了，下面举一些实际的例子，说明如何利用这几个看似简陋的组件来搞大新闻。延迟执行任务function taskSleep($ms){return new SysCall(function (Task $task) use ($ms) { swoole_timer_after($ms, function() use($task){ $task->send("this is send value in sleep function."); $task->run(); }); return Signal::TASK_SLEEP; });}function delay(){yield taskSleep(2000);}function gen(){echo "gen1\n"; yield 1; echo "gen2\n"; yield 2; echo "gen3\n"; yield 3;}//Task::execute(delay(), 1); 亦可(new Task(delay(), 1))->run();(new Task(gen(), 2))->run();/** output1| SYSCALLgen12| YIELD VALUEgen22| YIELD VALUEgen32| YIELD VALUE2| CHECKDONETask done 2//2秒以后//1| CHECKDONETask done 1**/taskSleep是个系统调用，告诉调度器我要睡眠了(传递给他一个Signal::TASK_SLEEP)。具体说明时候唤醒呢，要等swoole_timer_after2秒以后将它唤醒。我们这里同时跑了两个任务，从输出来看第一个任务的延时执行，并不会阻塞第二个任务。可以清楚地看到，我们的协程是可以实现多任务并行处理的(当然实际上并不是并行)。独立堆栈的子协程function justReturnValue(){yield (delay()); yield 'yield value 2';}function gen2(){$ret1 = (yield "yield value 1"); echo "[ret] $ret1\n"; $ret2 = (yield justReturnValue()); echo "[ret] $ret2\n";}(new Task(gen2(), 1))->run();/** output1| YIELD VALUE[ret] yield value 11| COROUTINE1| COROUTINE1| SYSCALL// 2秒以后 //1| TASKSTACK1| YIELD VALUE1| TASKSTACK[ret] yield value 21| CHECKDONETask done 1**/gen2里有一个子协程justReturnValue的调用，而justReturnValue里也有delay的子协程调用。通过输出可以清楚的看到，父子协程进栈出栈的顺序，以及出栈的协程会将吐出来的值交给原先的协程。实现一个非阻塞IO的Web服务参照那文里的实现，我们也可以写一个自己的Web服务。首先还是来说明一下要做什么，以及思路。直接引用那文的说法:有一个任务是在套接字上侦听是否有新连接，当有新连接要建立的时候，它创建一个新任务来处理新连接。Web服务器最难的部分通常是像读数据这样的套接字操作是阻塞的。例如PHP将等待到客户端完成发送为止。对一个Web服务器来说，这有点不太高效。因为服务器在一个时间点上只能处理一个连接。解决方案是确保在真正对套接字读写之前该套接字已经“准备就绪”. 为了查找哪个套接字已经准备好读或者写了, 可以使用 流选择函数传统的做法中，创建一个套接字，等待新连接，然后读取、发送、关闭。这些都是阻塞的，会花时间在这些抢占资源的步骤上。如果我们使用协程的方式，可以先将等待操作的任务yield掉，之后结合stream_select方法，选择出可以继续操作的任务将其resume。通俗的说，可以理解为大家一起挤公交车，原先必须一个一个上，但是上车以后要找公交卡，要刷卡或者投币，操作完了以后下一个乘客才能继续。如果使用协程的话，第一个乘客A上车以后，挂起到一边找公交卡，不影响第二个乘客B上车。等到A掏出公交卡以后，直接插队刷卡上车。虽然还是一个一个排队上车，但是找卡的时间里其他乘客不会干等了。socket的状态首先定义2个全局数组保存所有用到的socket。再定义2个系统调用将socket设置进数组里，并且返回等待信号量让Task挂起。$waitingForRead = [];$waitingForWrite = [];function waitForRead($socket) {return new SysCall( function(Task $task) use ($socket) { global $waitingForRead; if (isset($waitingForRead[(int) $socket])) { $waitingForRead[(int) $socket][1][] = $task; } else { $waitingForRead[(int) $socket] = [$socket, [$task]]; } //设置完了不让他往下走 return Signal::TASK_WAIT; } );}function waitForWrite($socket) {return new SysCall( function(Task $task) use ($socket) { global $waitingForWrite; if (isset($waitingForWrite[(int) $socket])) { $waitingForWrite[(int) $socket][1][] = $task; } else { $waitingForWrite[(int) $socket] = [$socket, [$task]]; } //设置完了不让他往下走 return Signal::TASK_WAIT; } );}选择可以操作的socket注册一个任务，不断检查我们的全局数组，直到有socket就绪了，将其对应的任务唤醒。function ioPoll($timeout) {global $waitingForRead; global $waitingForWrite; $rSocks = []; foreach ($waitingForRead as list($socket)) { $rSocks[] = $socket; } $wSocks = []; foreach ($waitingForWrite as list($socket)) { $wSocks[] = $socket; } $eSocks = []; // dummy //stream_select 方法会直接修改入参 只保留就绪的socket数组 if (false === stream_select($rSocks, $wSocks, $eSocks, $timeout)) { return; } foreach ($rSocks as $socket) { list(, $tasks) = $waitingForRead[(int) $socket]; unset($waitingForRead[(int) $socket]); foreach ($tasks as $task) { $task->send("ready for read"); $task->run(); } } foreach ($wSocks as $socket) { list(, $tasks) = $waitingForWrite[(int) $socket]; unset($waitingForWrite[(int) $socket]); foreach ($tasks as $task) { $task->send("ready for write"); $task->run(); } }}function ioPollTask() {global $waitingForRead; global $waitingForWrite; while (true) { if(count($waitingForRead) <=1 && count($waitingForWrite) <=1){ //如果等待检查的socket只有1个 则用阻塞的方式等待 ioPoll(null); }else{ //否则设为0超时 ioPoll(0); } yield; }}封装socket将socket封装一下，定义了必须的4个方法。class CoSocket {protected $socket; public function __construct($socket) { $this->socket = $socket; } public function accept() { //等待本socket就绪 yield waitForRead($this->socket); //就绪以后会继续走到这里 返回给外层一个客户端连接socket yield stream_socket_accept($this->socket, 0); } public function read($size) { //等待本socket就绪 yield waitForRead($this->socket); //就绪以后回把读取到的内容 返回给外层 yield fread($this->socket, $size); } public function write($string) { //等待本socket就绪 yield waitForWrite($this->socket); //就绪以后把响应写给客户端 fwrite($this->socket, $string); } public function close() { @fclose($this->socket); }}处理客户端新连接服务端socket接受到新的连接以后，创建新的任务。下面是这个任务里实际运行的协程。function handleClient(CoSocket $socket) {$data = (yield $socket->read(8192)); $msg = "Received following request:\n\n$data"; $msgLength = strlen($msg); //响应报文由状态行(HTTP版本、状态码)+HTTP首部字段(响应首部字段、通用首部字段、实体首部字段)组成。 //空行(CR+LF)分隔首部与报文主体。所以这里留个空行在打印$msg $response = <<<RESHTTP/1.1 200 OK\rContent-Type: text/plain\rContent-Length: $msgLength\rConnection: close\r\r$msgRES;yield $socket->write($response); yield $socket->close();}开启服务！直接创建一个包含server协程的任务，和一个不断刷新stream_select的任务。之后的流程都交给ioPollTask来调度了。//定义全局的taskId自增用static $stTaskId = 1;function server($port){echo "Starting server at port $port...\n"; //这里抛出的异常会被scheduler和task抛来抛去 最后还是到这里catch一下 try{ $socket = @stream_socket_server("tcp://localhost:$port", $errNo, $errStr); if (!$socket) throw new Exception($errStr, $errNo); //设置为读写非阻塞 stream_set_blocking($socket, 0); $socket = new CoSocket($socket); while (true) { $clientSocket = (yield $socket->accept()); $clientCoSocket = new CoSocket($clientSocket); //为新的链接创建Task Task::execute(handleClient($clientCoSocket)); } }catch (Exception $e){ echo $e->getMessage(); }}//创建服务端socket的task 1Task::execute(server(8000));//不断刷新socket_select的task 2Task::execute(ioPollTask());运行效果开启服务后，我们先直接用curl访问，观测一下得到的结果。➜ ~ curl -d "a=123&b=456" http://localhost:8000Received following request:POST / HTTP/1.1Host: localhost:8000User-Agent: curl/7.51.0Accept: /Content-Length: 11Content-Type: application/x-www-form-urlencodeda=123&b=456可以看到服务端吐出了我们发送给他的信息，包括HTTP请求行、首部字段和正文。如果我们在浏览器里访问的话，正文内容会丰富许多，会有Cookie,UA等等，如下：Received following request:GET / HTTP/1.1Host: localhost:8000Connection: keep-aliveUpgrade-Insecure-Requests: 1User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,/;q=0.8DontTrackMeHere: gzip, deflate, sdch, brAccept-Language: zh-CN,zh;q=0.8,en;q=0.6,zh-TW;q=0.4Cookie: Phpstorm-f86ac615=34137ba0-5113-4922-b809-b6fa20dbf937不足的地方zan framework里的协程调度，并没有采用任务队列的方式。可能是因为他只是针对单独的http或者tcp请求来设计的吧，一般是链式调用。由于这个原因，所以没法设置具体某个任务的执行顺序。当然实际效果跟那文里是相同的，说到底还是由ioPollTask来驱动。小结我们通过几个例子加深了对PHP中协程用法的理解。需要注意的是，在协程中(本文构造的这种结构)我们要避免使用死循环，除非循环里yield的结果可以将其挂起并出让控制权给其他协程。比如上文的Web服务器中，因为有不能主动挂起的ioPollTask，所以不能实现在响应时延迟几秒的效果。因为即使使用了taskSleep这种系统调用，也会因为ioPollTask死循环导致不能获取控制权无法执行

在 PHP 中使用 Promise + co/yield 协程 在 PHP 中使用 Promise + co/yield 协程摘要: 我们知道 JavaScript 自从有了 Generator 之后，就有了各种基于 Generator 封装的协程。其中 hprose 中封装的 Promise 和协程库实现了跟 ES2016 的 async/await 一样的功能，并且更加灵活。我们还知道 PHP 自从 5.5 之后，也引入了 Generator，同样也有了各种基于它封装的 PHP 协程库，hprose 同样也为 PHP 提供的跟 JavaScript 版本类似的 Promise 和协程库。下面我们就来看一下它跟 swoole 结合的效果。为什么需要异步方式一个函数执行之后，在它后面顺序编写的代码中，如果能够直接使用它的返回结果或者它修改之后的引用参数，那么我们通常认为该函数是同步的。而如果一个函数的执行结果或者其修改的引用参数，需要通过设置回调函数或者回调事件的方式来获取，而在其后顺序编写的代码中无法直接获取的话，那么我们通常认为这样的函数是异步的。PHP 提供的大部分函数都是同步的。通常我们会有一个误解，那就是容易把同步和阻塞当成同一个概念，但实际上同步代码不一定都是阻塞的，只是同步代码对阻塞天然友好，当同步代码和阻塞结合时，代码通常是简单易懂的。阻塞带来的问题是当前线程（或进程）会陷入等待，一直等到阻塞结束，这样就会造成线程（或进程）资源的浪费。所以，通常认为阻塞是不够高效的。但是如果要编写非阻塞代码，使用同步方式会变得有些复杂，且不够灵活。同步方式的非阻塞代码通常会使用 select 模式，例如 curl_multi_select, stream_select, socket_select 等就是 PHP 中提供的一些典型的 select 模式的函数。我们说它复杂且不够灵活是有理由的，例如使用上面的 select 模式编写同步的非阻塞代码时，我们需要先构造一个并发任务的列表，之后手动构造循环来执行这些并发的任务，在循环开始之后，虽然这几个任务可以并发，但是这个循环相对于其后的代码总体上仍然是阻塞的，我们要想拿到这些并发任务的结果时，仍然需要等待。select 虽然可以同时等待多个任务中某一个或几个就位后，再执行后续操作，但仍然有一部分时间是被等待消耗掉的。而且如果是纯同步非阻塞的情况下，我们也很难在循环开始后，动态添加更多的任务到这个循环中去。所以，如果我们希望程序能够更加高效，更加灵活，就需要引入异步方式。传统的异步方式有什么问题一提到异步模式，大家脑子中的第一印象可能就是回调、回调、回调。是的，这是最简单最直接也是之前最常见的异步模式。只要在调用异步函数时设置一个或多个回调函数，函数就会在完成时自动调用回调函数。或者为一个对象设置一堆事件，之后调用该对象上的某个异步方法，虽然这个异步方法本身可能不再需要设置回调函数，但是设置的这堆事件实际上跟回调函数所起到的作用是一样的。如果你的程序逻辑够简单，简单的一两层回调也许并不会让你觉得异步方式的编程有什么麻烦。但如果你的程序逻辑一旦有些复杂，你可能就会被层层回调搞得疲惫不堪了。当然，实际上你的程序需要层层回调的原因，也许并不是你的程序逻辑真的复杂，而是你没有办法将回调函数中的参数结果传出来，所以，你就不得不将另一个回调函数传进去。我们来举一个简单的例子，假设我们有 1 个同步函数：function sum($a, $b) {return $a + $b;}然后我们按照下面的方式去调用它：$a = sum(1, 2);$b = sum($a, 3);$c = sum($b, 4);var_dump(array($a, $b, $c));虽然上面的代码很不精简，但我们要表达的意图很明确，而且代码看起来很清楚。那接下来我们把这个函数换成一个形式上的异步函数，例如：function async_sum($a, $b, $callback) {$callback($a + $b);}当然，它的执行并不是异步的，这里我们先不关心它的实现是不是真异步的。现在如果要做上面同样的操作，代码就要这样写了：async_sum(1, 2, function($a) {async_sum($a, 3, function($b) use ($a) { async_sum($b, 4, function($c) use ($a, $b) { var_dump(array($a, $b, $c)); }); });});代码的执行结果是一样的。但异步的代码看起来显然更难读一些，虽然这已经是很简单的例子了。好了，看到这里，有些读者可能会觉的我上面的这个例子很糟糕。因为明明有同步的函数可以使用，并且代码清晰可读，为啥非要写个形似异步的函数，把本来同步可以做的很好的事情用异步方式复杂化呢？而且那个异步调用的方式，最后不还是想要实现同步化的结果吗？如果你这么想的话，一点都没错。但我们这里想要解决的问题是，如果我们拿到的只有一个异步函数，这个函数没有同步实现，我们也不知道这个异步函数的内部定义是怎样的，我们也没办法将这个异步函数改为同步函数实现。那我们有没有办法将上面的程序改的更可读一些呢？当然是可以的，所以，现在 Promise 要登场了。为什么要引入 Promise通常我们对 Promise 的一个误解就是，它要解决的是层层回调的问题，比如上面的问题看上去就是一个典型的层层回调的问题。然而实际上，Promise 要解决的并不是回调不回调的问题，如果你使用过 Promise 的话，你会发现使用 Promise 你仍然少不了要使用回调。Promise 要解决的问题是，如何将回调方法的参数从回调方法中传递出来，让它可以像同步函数的返回结果一样，在回调函数以外的控制范围内，可以传递和复用。下面这几篇文章可能会对大家理解 Promise 有所帮助：深入理解 Promise 五部曲：1. 异步问题深入理解 Promise 五部曲：2. 控制权转换问题深入理解 Promise 五部曲：3. 可靠性问题深入理解 Promise 五部曲：4. 扩展问题深入理解 Promise 五部曲：5. LEGO我觉得这几篇文章讲的比较透彻，所以我就不重复文章中的内容了。下面我们来看上面的例子用 Promise 如何解。我们现在用最简单粗暴的方式来引入 Hprose 的库，直接复制源码而不是使用 composer。然后我们在代码中直接使用：<?phprequire_once("Hprose.php");use Hprose\Promise;这种方式来引入 Hprose 的 Promise 库，当然你也可以写成：<?phprequire_once("Hprose.php");use Hprose\Future;Future 库跟 Promise 库基本上是一样的，你可以认为 Future 是 Promise 的具体实现，Promise 只是 Future实现的一个包装。这个区别你可以从源码中直接看出来，这里就不多做解释了。接下来，我们要把前面的 async_sum 函数 Promise 化，Hprose 提供了这样一个函数：Promise\promisify（或者 Future\promisify），它的作用就是将一个使用回调方式的异步函数变成一个返回 Promise 对象的异步函数。这样说，也许有些不好理解，下面直接上代码：<?phprequire_once("Hprose.php");use Hprose\Promise;function async_sum($a, $b, $callback) {$callback($a + $b);}$sum = Promise\promisify('async_sum');$a = $sum(1, 2);$b = $a->then(function($a) use ($sum) {return $sum($a, 3);});$c = $b->then(function($b) use ($sum) { return $sum($b, 4);});Promise\all(array($a, $b, $c))->then(function($result) {var_dump($result);});好了，看到这里，如果你对 Promise 的理解还不够深入的话，你的第一反应可能是：这不是把程序变得更复杂了吗？原来的程序是 3 个回调，现在仍然是 3 个回调，还多了包装，都玩出花来了，有意思吗？确实，从上面的代码来看，代码并没有被简化，但是你会发现，现在回调函数中的参数已经通过 Promise 返回值的方式传递出来了，而且可以在原本的回调函数控制范围以外被传递和复用了。但是你可能会说然并卵，程序不是仍然很复杂吗？那我们就来进一步简化一下：<?phprequire_once("Hprose.php");use Hprose\Promise;function async_sum($a, $b, $callback) {$callback($a + $b);}$sum = Promise\wrap(Promise\promisify('async_sum'));$var_dump = Promise\wrap('var_dump');$a = $sum(1, 2);$b = $sum($a, 3);$c = $sum($b, 4);$var_dump(Promise\all(array($a, $b, $c)));现在，代码中再也看不到回调了。因为我们把函数包装成了可以接收 Promise 变量的函数。当然，其实现细节略微有些复杂，如果你感兴趣，可以去看一下源码，这里就不做源码剖析了。如果感兴趣的读者多得话，以后有时间再写源码剖析。当然，如果你只是想把异步调用同步化，除了 Promise\wrap 外，你还可以通过 co/yield 协程来实现。Hprose 中的 co/yield 协程还是上面的例子，如果你使用的是 PHP 5.5 或者更高版本，那么你可以这样来写代码了。<?phprequire_once("Hprose.php");use Hprose\Promise;function async_sum($a, $b, $callback) {$callback($a + $b);}Promise\co(function() {$sum = Promise\promisify('async_sum'); $a = (yield $sum(1, 2)); $b = (yield $sum($a, 3)); $c = (yield $sum($b, 4)); var_dump(array($a, $b, $c));});这代码比使用 Promise\wrap 的又要简单了。这里，代码中的变量 $a, $b, $c 不再是 Promise 变量，而是实实在在的整数变量。也就是说，yield 把一个 Promise 变量变成了一个普通变量。现在 Promise\co 中的代码已经被实实在在的同步化了。现在你可能有新的疑问了，异步不是为了高效吗？现在把原本的异步代码同步化了，那还会高效吗？当然，对这个例子上来说，效率肯定是没有提高，反而是严重降低的。甚至在这个例子中，最原始的那个形似异步的实现也不比同步实现更高效。因为在这个例子中，并没有涉及到并发和 IO 阻塞的情况。下面我们就放到真实场景下来看看 Promise 和 co/yield 协程是怎么用的。在 swoole 下使用 Promise 和 co/yield 协程我们知道在 PHP 中，如果要让程序延时可以使用 sleep 函数（或者 usleep, time_nanosleep 函数）来让程序阻塞一会儿，但是这个阻塞会让整个进程都阻塞，所以在阻塞期间，什么都不能干。下面我们来看看使用 swoole_timer_after 实现的延时执行：<?phprequire_once("Hprose.php");use Hprose\Future;date_default_timezone_set('UTC');function wait($time) {$wait = Future\promisify('swoole_timer_after'); for ($i = 0; $i < 5; $i++) { yield $wait($time); var_dump("wait ". ($time / 1000) . "s, now is " . date("H<img align="absmiddle" alt="i" class="emoji" src="https://static.hacpai.com/emoji/graphics/i.png" title="i"></img>s")); }}Future\co(wait(2000));Future\co(wait(1000));该程序执行结果如下：string(24) "wait 1s, now is 13:48:25"string(24) "wait 2s, now is 13:48:26"string(24) "wait 1s, now is 13:48:26"string(24) "wait 1s, now is 13:48:27"string(24) "wait 2s, now is 13:48:28"string(24) "wait 1s, now is 13:48:28"string(24) "wait 1s, now is 13:48:29"string(24) "wait 2s, now is 13:48:30"string(24) "wait 2s, now is 13:48:32"string(24) "wait 2s, now is 13:48:34"从结果中我们可以看出，wait(2000) 和 wait(1000) 各自都是顺序阻塞执行的，但是它们之间却是并发执行的。也就是说，协程之间并不会相互阻塞，虽然这几个并发的协程是在同一个进程内跑的。最后我们再来看一个用 co/yield 协程实现的并发抓图程序：<?phprequire_once("Hprose.php");use Hprose\Promise;function fetch($url) {$dns_lookup = Promise\promisify('swoole_async_dns_lookup'); $writefile = Promise\promisify('swoole_async_writefile'); $url = parse_url($url); list($host, $ip) = (yield $dns_lookup($url['host'])); $cli = new swoole_http_client($ip, isset($url['port']) ? $url['port'] : 80); $cli->setHeaders([ 'Host' => $host, "User-Agent" => 'Chrome/49.0.2587.3', ]); $get = Promise\promisify([$cli, 'get']); yield $get($url['path']); list($filename) = (yield $writefile(basename($url['path']), $cli->body)); echo "write $filename ok.\r\n"; $cli->close();}$urls = array('http://b.hiphotos.baidu.com/baike/c0%3Dbaike116%2C5%2C5%2C116%2C38/sign=5f4519ba037b020818c437b303b099b6/472309f790529822434d08dcdeca7bcb0a46d4b6.jpg', 'http://f.hiphotos.baidu.com/baike/c0%3Dbaike116%2C5%2C5%2C116%2C38/sign=1c37718b3cc79f3d9becec62dbc8a674/38dbb6fd5266d016dc2eaa5c902bd40735fa358a.jpg', 'http://h.hiphotos.baidu.com/baike/c0%3Dbaike116%2C5%2C5%2C116%2C38/sign=edd05c9c502c11dfcadcb771024e09b5/d6ca7bcb0a46f21f3100c52cf1246b600c33ae9d.jpg', 'http://a.hiphotos.baidu.com/baike/c0%3Dbaike92%2C5%2C5%2C92%2C30/sign=4693756e8094a4c21e2eef796f9d70b0/54fbb2fb43166d22df5181f5412309f79052d2a9.jpg', 'http://a.hiphotos.baidu.com/baike/c0%3Dbaike92%2C5%2C5%2C92%2C30/sign=9388507144a98226accc2375ebebd264/faf2b2119313b07eb2cc820c0bd7912397dd8c45.jpg',);foreach ($urls as $url) {Promise\co(fetch($url));}在这个程序中，fetch 函数内的代码是同步执行的，但是多个 fetch 之间却是并发执行的，从结果输出就可以看出来，输出顺序是不一定的。但最后，你总能得到所有的美图。总结：通过 swoole 跟 hprose 中的 Promise 和 co/yield 协程相结合，你可以方便的使用同步的方式来调用 swoole 中的异步函数和方法，并可以实现协程间的并发。因为篇幅所限，这里无法把 hprose 中 Promise 和 co/yield 协程的全部内容都介绍完，如果你想了解更多，可以参考下面两篇内容：Promise 异步编程co/yield 协程