PHP如何利用协程并发HTTP请求提升数据采集整体效率

各位同学，大家好！

今天我们要聊一个在PHP圈子里既性感又痛彻心扉的话题——数据采集。

我知道你们中的很多人，手里攥着成千上万个URL列表，心里盘算着“只要用个foreach循环，套个file_get_contents，今晚就能早睡”，然后满怀期待地去上厕所，回来发现屏幕上只跑完了5%的任务。

那一刻，你的CPU在尖叫，你的PHP进程在沉睡，你的自尊心在碎裂。

别哭，兄弟。今天，我要教你们如何通过PHP协程，把你的单线程PHP变成一只拥有千手观音能力的“超级蜘蛛”，让数据采集不再是慢动作回放，而是像《速度与激情》一样飞驰。

准备好了吗？我们要换挡了。

一、 同步代码的“便秘”体验：为什么我们要换挡？

我们先来聊聊为什么传统的PHP采集代码像便秘一样痛苦。

假设你要采集10个网页，每个网页平均加载需要1秒。你的代码大概长这样：

$urls = [
    'http://example.com/1',
    'http://example.com/2',
    // ... 一共10个
];

foreach ($urls as $url) {
    $content = file_get_contents($url); // 这家伙会一直等到服务器回应
    // 处理数据...
    echo "完成 $urln";
}

这看起来没问题，对吧？但是！在file_get_contents的这1秒钟里，你的PHP进程在干嘛？

它在发呆。它就像一个在银行柜台排队的人，前面的人办业务（服务器处理请求），你在后面傻等。哪怕柜台的小哥手里正忙着处理你的申请，你也得在那儿瞪着眼睛等着。

10个请求 × 1秒 = 10秒。
100个请求 × 1秒 = 100秒。
10000个请求 × 1秒 = 10000秒（快3个小时）。

这哪里是采集数据，这简直是数据考古！

同步I/O的痛点在于：当程序在等待网络返回数据时，CPU完全闲置，内存空转。对于PHP这种语言来说，我们更擅长做逻辑运算，而不是死等。所以，我们要用协程，来实现“并发”。

二、 什么是协程？它是你的“分身术”

协程，听起来很高大上，其实就是“主动让步”。

在传统的单线程模型里，你一旦开始等I/O（比如等HTTP响应），CPU就交出控制权给别人。但在协程里，你可以让出CPU，去做点别的事，然后等那个I/O回来的时候，你自动“切回来”继续干活。

这就好比：

• 同步： 你叫了一个外卖。你站在门口盯着楼道口，一动不动，直到外卖小哥出现。（效率极低）
• 协程： 你叫了外卖，然后回家洗个澡、刷刷剧。外卖小哥到了，门铃响了，你洗完澡出来拿。你的大脑没有一直放在“等外卖”这件事上。

在PHP中，Swoole、Workerman、Amp等扩展就是实现协程的引擎。它们接管了底层的I/O操作，让你写出来的代码是“同步”的，但底层执行起来是“并发”的。

三、 实战一：让Guzzle飞起来

在PHP界，Guzzle HTTP Client是霸主。但是，Guzzle默认是同步的，它会阻塞你的程序。

要利用协程并发，你需要给Guzzle安上一双“Swoole的翅膀”。

首先，确保你安装了guzzlehttp/guzzle和swoole。

我们要利用Swoole提供的AsyncHttpClient来构建一个Guzzle的Adapter。这样，你依然可以使用Guzzle熟悉的链式调用，但底层的网络请求却是异步并发的。

require_once 'vendor/autoload.php';

use GuzzleHttpClient;
use GuzzleHttpHandlerStack;
use SwooleCoroutineHttpClient as SwooleClient;

// 这是一个自定义的Swoole Handler
class SwooleHandler
{
    public function __invoke($request, array $options)
    {
        // 创建一个协程HTTP客户端
        $client = new SwooleClient($request->getUri()->getHost(), $request->getUri()->getPort() ?: 80);

        // 设置超时时间
        $client->set(['timeout' => 10]);

        // 设置请求方法和路径
        $client->setMethod($request->getMethod());
        $client->setData($request->getBody()->getContents());

        // 设置Headers
        $headers = $request->getHeaders();
        foreach ($headers as $key => $values) {
            foreach ($values as $value) {
                $client->setHeaders([$key => $value]);
            }
        }

        // 发起请求
        $client->execute();

        // 如果有响应头
        $responseHeaders = [];
        foreach ($client->headers as $key => $values) {
            $responseHeaders[$key] = $values;
        }

        // 构造Guzzle Response对象
        return new GuzzleHttpPsr7Response(
            $client->statusCode,
            $responseHeaders,
            $client->body
        );
    }
}

// 构建配置
$config = [
    'handler' => new SwooleHandler(), // 关键：注入协程处理器
    'base_uri' => 'https://httpbin.org',
    'timeout' => 10,
];

$client = new Client($config);

// 并发请求10个接口
$urls = [
    '/delay/1',
    '/delay/1',
    '/delay/1',
    '/delay/1',
    '/delay/1',
    '/delay/1',
    '/delay/1',
    '/delay/1',
    '/delay/1',
    '/delay/1',
];

$startTime = microtime(true);

$promises = [];
foreach ($urls as $url) {
    // 创建Promise
    $promises[$url] = $client->getAsync($url);
}

// 等待所有请求完成（真正的并发发生在这里，而不是在foreach里）
$results = GuzzleHttpPromiseUtils::settleAll($promises)->wait();

$endTime = microtime(true);
echo "总耗时: " . ($endTime - $startTime) . " 秒n";

// 打印结果
foreach ($results as $url => $result) {
    if ($result['state'] === 'fulfilled') {
        echo "成功: $url -> " . substr($result['value']->getBody(), 0, 50) . "...n";
    } else {
        echo "失败: $url -> " . $result['reason']->getMessage() . "n";
    }
}

看懂了吗？

注意那个settleAll。传统的foreach循环是在排队，而这个代码是在集合所有任务后一次性发车。虽然我们要等所有车都回来，但在路上的这1分钟里，我们的协程是在后台高速切换的。总耗时从10秒变成了1秒左右（受限于最慢的那个请求，或者网络传输）。

这就是并发！这就是效率！

四、 架构设计：打造你的“狼群”

仅仅并发请求还不够。真实的采集场景比这个复杂得多。你需要任务队列、去重、重试、异常处理。这才是资深专家该关心的。

这里我们引入一个经典的生产者-消费者模型。

1. 任务队列

不要把所有URL都塞进一个数组里。如果采集量巨大，内存会炸。我们需要把任务存到Redis里，或者利用Swoole自带的Table（内存表，速度快，但不持久）。

这里我们用最简单的内存数组队列来演示逻辑（生产环境请用Redis）：

class Queue
{
    private $queue = [];
    private $lock; // 简单的锁机制

    public function push($item)
    {
        $this->queue[] = $item;
    }

    public function pop()
    {
        return array_shift($this->queue);
    }

    public function count()
    {
        return count($this->queue);
    }
}

// 初始化队列
$taskQueue = new Queue();

// 假设这是你的种子链接生成器
$seedUrls = ['http://example.com/page1', 'http://example.com/page2', ...];
foreach ($seedUrls as $url) {
    $taskQueue->push(['type' => 'fetch', 'url' => $url]);
}

// 启动一批工作协程
$workers = 10; // 10个并发工人

for ($i = 0; $i < $workers; $i++) {
    go(function () use ($taskQueue) {
        $client = new Client([
            'handler' => new SwooleHandler(),
            'timeout' => 10
        ]);

        while (true) {
            // 从队列取任务
            $task = $taskQueue->pop();

            if (!$task) {
                // 队列空了，或者被清空了，休眠一下或者退出
                // 这里为了演示无限循环，我们假设有源源不断的任务
                sleep(1);
                continue;
            }

            // 像个真正的工人一样干活
            try {
                echo "Worker {$i} 正在抓取: {$task['url']}n";
                $response = $client->getAsync($task['url'])->wait(); // wait()在这里是阻塞当前协程等待结果

                // 解析数据...
                // 发现新链接，继续丢进队列
                $newLinks = parseLinks($response->getBody());
                foreach ($newLinks as $link) {
                    $taskQueue->push(['type' => 'fetch', 'url' => $link]);
                }

            } catch (Exception $e) {
                echo "Worker {$i} 失败: " . $e->getMessage() . "n";
                // 失败了怎么办？重试或者丢到失败队列，这里简单处理
            }
        }
    });
}

这段代码展示了无限循环的工作流。10个协程会在后台不断从队列里拿任务、执行、解析、再扔任务。这就是所谓的“狼群战术”。

五、 防反爬策略：HTTP/2与Header的博弈

既然你用了协程，那你的速度会比普通爬虫快几十倍。服务器看着你的流量猛增，会怎么想？

“这是攻击吗？这是机器人吗？”

所以，利用协程的优势，我们要更智能地反反爬。

1. HTTP/2 多路复用

传统的HTTP/1.1，每个请求都要建立一个新的TCP连接（三次握手）。如果你有1000个请求，就要建立1000次连接。这很慢，也很费资源。

但是，HTTP/2允许在一个TCP连接上发送多个请求。

Swoole的HTTP客户端原生支持HTTP/2。如果你连接到支持HTTP/2的服务器，你可以大大减少连接数。

// 开启 HTTP/2
$client = new SwooleCoroutineHttpClient('https://http2.golang.org', 443, true);
$client->set(['timeout' => 5]);

// 一次发起5个请求，但可能共用一个TCP连接
$client->post('/get', ['data' => 'test1']);
$client->post('/get', ['data' => 'test2']);
$client->post('/get', ['data' => 'test3']);
// ...

echo $client->body;

这简直就是魔法！这能极大地降低服务器的连接压力，同时提升你的采集速度。这就是协程的另一个Buff：节省资源。

2. 代理轮换与User-Agent池

协程允许你在每个请求中轻松注入不同的Header。

// 随机User-Agent库
$uaList = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36',
    'Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1'
];

// 随机代理库
$proxyList = [
    'tcp://192.168.1.1:8080',
    'tcp://192.168.1.2:8080',
];

function getRandomUa() {
    global $uaList;
    return $uaList[array_rand($uaList)];
}

function getRandomProxy() {
    global $proxyList;
    return $proxyList[array_rand($proxyList)];
}

// 在Worker中
$task = [
    'url' => 'http://example.com/data',
    'headers' => [
        'User-Agent' => getRandomUa(),
        'Referer' => 'http://example.com',
    ],
    'proxy' => getRandomProxy() // Swoole Client支持代理
];

协程的优势在于，你可以让每个Worker都维护一套自己的Header池，完全互不干扰。

六、 异常处理与稳定性：不要让你的爬虫“猝死”

协程虽然强大，但也是一把双刃剑。如果某个请求卡死了，或者某个页面的解析代码写错了，协程可能会崩溃，甚至拖垮整个进程（虽然Swoole的Reactor机制比普通的while(true)强得多）。

1. 超时控制是生命线

网络是不稳定的。不要让一个请求等上一天。

$client->set(['timeout' => 5]); // 5秒超时
try {
    $response = $client->getAsync($url)->wait();
} catch (SwooleCoroutineHttpClientException $e) {
    if ($e->getCode() == SwooleCoroutineHttpClient::ERR_TIMEOUT) {
        echo "请求超时: $urln";
        // 记录到失败队列，过一会重试
    }
}

2. 内存监控

PHP是动态语言，容易内存泄漏。在协程环境下，如果你的$queue或者缓存无限增长，内存会溢出。

// 定期检查内存
if (memory_get_usage() > 100 * 1024 * 1024) { // 超过100MB
    // 清理缓存，或者强制GC
    gc_collect_cycles();
    echo "内存告警，执行清理n";
}

七、 进阶：分布式采集与TCP长连接

如果你的单机CPU算力不够，或者单机带宽被限制，怎么办？

协程允许你实现分布式采集。你可以写一个简单的Master节点，管理多个Worker节点。

Master负责：

1. 分发任务给Worker。
2. 收集结果。

Worker负责：

1. 接收任务。
2. 使用协程并发执行。

利用Swoole的SwooleCoroutineClient，你可以建立Master与Worker之间的通信通道。甚至，你可以利用WebSocket连接Master，实现实时状态反馈。

想象一下，你有一台高性能的服务器作为Master，10台低性能的VPS作为Worker。Master发号施令，Workers像听话的兵一样飞快地干活。这就是真正的“云端协作”。

八、 总结：从“人肉脚本”到“工业流水线”

各位同学，从最开始那个对着屏幕发呆的file_get_contents循环，到今天我们构建的这套基于协程的采集系统，你们看到的不仅仅是代码的变化，更是思维方式的升级。

我们利用协程解决了阻塞问题。
我们利用Guzzle Adapter解决了接口复杂度问题。
我们利用HTTP/2解决了网络协议瓶颈。
我们利用队列模型解决了任务管理问题。

PHP不再是一个只能做页面的脚本语言。在Swoole、RoadRunner、PHP-FPM 8.1+等技术的加持下，它完全可以胜任高并发、高吞吐的后端服务。

记住，并发不是目的，解决痛点才是。当你看到你的采集任务从跑一天变成跑5分钟，当你看到你的日志里充满了“成功抓取”而不是“连接超时”时，你就知道，你真的变强了。

现在，去把你的爬虫改造成协程版吧！别再让你的服务器在深夜里独自流泪了。Go Go Go！