PHP如何利用共享内存缓存替代Redis降低网络通信损耗

各位同学，大家好。

今天我们不聊那些花里胡哨的新框架，也不聊怎么优化 SQL 查询语句。今天我们要聊一个稍微“硬核”一点，但在某些特定场景下能让你爽到飞起的话题：如何用 PHP 的共享内存，把你的 Redis 给干掉（或者说，让 Redis 去干些更轻松的活）。

很多同学一听到“共享内存”，脑子里蹦出来的可能是 C 语言里的指针操作，或者是什么黑科技的黑客技术。其实没那么玄乎。在今天的讲座里，我会带着你们，像剥洋葱一样，把这层技术的外衣剥开，看看 PHP 是如何在内存条里“打架”的——哦不，是“协作”的。

我们今天的主题是：利用共享内存替代 Redis，以零网络延迟换取极致性能。

---

第一课：当你的 CPU 等待网络握手时，它在想什么？

首先，我们要搞清楚一个痛点。现在的 PHP 架构，基本上都是 Nginx + PHP-FPM。你的 PHP 代码想读个缓存，得走这一套流程：

1. PHP 代码说：“嘿，我想拿个数据。”
2. TCP 协议：“好嘞，握手！”（SYN, SYN-ACK, ACK，这一套下来，CPU 得转好几圈）。
3. Redis 服务端：“数据是啥？”
4. Redis：“给，这是你要的 JSON 字符串。”
5. PHP 代码：“收到！”

这中间有个致命的问题：网络通信延迟。

哪怕你的 Redis 就在隔壁机房，哪怕它跑在本地回环地址 127.0.0.1 上，TCP/IP 协议栈也要工作，操作系统内核要拷贝数据。更重要的是，PHP 默认的序列化/反序列化（比如 serialize 和 unserialize），就像是用快递把东西包起来，再拆开。

现在，想象一下，你的系统每秒处理 10 万次请求。每一次请求都要经历这一套“拿快递-拆快递”的过程。如果你只是想存个简单的计数器，或者存个“用户登录状态”，或者记录一下 API 的耗时，你真的值得为了这 0.1 毫秒的网络开销，去启动一个 Redis 服务吗？

共享内存，就是那个把“快递员”干掉，让你直接伸手进箱子里拿东西的家伙。

---

第二课：共享内存是个什么鬼？

共享内存，顾名思义，就是两个（或多个）进程，映射到同一块物理内存区域。

这就好比你和一个朋友分用一张桌子写作业。你们不需要互相喊话，谁写完了，谁就往桌面上放个东西。另一个人只要一抬头，就能看到。

在 Linux/Unix 系统中，我们可以通过 shmop（System V Shared Memory Operations）这个扩展来实现它。

核心优势：

• 零拷贝：数据不需要离开 CPU 缓存，不需要经过网络协议栈。
• 极速：基本上是内存级别的读写速度。
• 无序列化：你可以直接读写二进制数据，省去 PHP 自带序列化的开销。

核心风险：

• 同步问题：如果两个人同时伸手进箱子拿东西，或者一个人在写的时候另一个人在读，数据就乱了。这就需要“锁”。
• 生命周期：PHP 进程重启了，内存还在吗？还在，除非你手动删除。这既是优点也是缺点。

---

第三课：如何在 PHP 里玩转内存块？

PHP 自带的 shmop 扩展提供了几个函数：

• shmop_open: 打开一块内存。
• shmop_write: 写入数据。
• shmop_read: 读取数据。
• shmop_delete: 标记删除（但不会立即释放）。
• shmop_close: 关闭（这个函数其实不存在，shmop_open 返回的 resource 会由 PHP GC 管理）。

看起来很简单？别急，这才是最坑的地方。PHP 的共享内存是“字节流”。它不认识你定义的 $user['name'] = 'ZhangSan'。在内存里，这就是一堆乱七八糟的 0 和 1。

3.1 基础实战：创建你的第一个内存块

我们假设你要存一个简单的计数器。

<?php
// 打开一块名为 'my_shared_cache'，大小为 1024 字节的共享内存块
// flags: 0644 (权限), mode: 0 (如果不存在则创建)
$shm_id = shmop_open('my_shared_cache', 'c', 0644, 1024);

if ($shm_id) {
    echo "成功创建共享内存块！n";

    // 准备要写入的数据
    $data = "Hello Shared Memory!";

    // 写入数据
    // shmop_write 返回实际写入的字节数，不一定等于 strlen($data)，注意检查返回值！
    $bytes_written = shmop_write($shm_id, $data, 0);

    echo "写入 $bytes_written 字节n";

    // 读取数据
    $shm_size = shmop_size($shm_id);
    $read_data = shmop_read($shm_id, 0, $shm_size);

    echo "读取到数据: " . $read_data . "n";

    // 删除这块内存（只是标记删除，实际内存不会立即释放，直到最后一个引用关闭）
    shmop_delete($shm_id);
    shmop_close($shm_id);
} else {
    echo "创建失败！n";
}

这段代码运行起来非常快，但有个大问题：没法区分你存了两次数据。 第二次写入会把第一次的数据覆盖掉，根本没地方存 key-value 啊！

---

第四课：内存里的“协议”与“结构体”

要做成一个真正的缓存系统，你得自己设计内存布局。这就像是用 C 语言写结构体，但你要在 PHP 里控制位操作。

假设我们要做一个简单的 KV 存储，键长度固定，值长度固定。

内存布局设计：

+---------------------+
| Key (32 Bytes)      | <-- 从偏移量 0 开始
+---------------------+
| Value (100 Bytes)   | <-- 从偏移量 32 开始
+---------------------+
| TTL (4 Bytes Int)   | <-- 从偏移量 132 开始
+---------------------+

• 优点：读取极快，不需要遍历数组，直接 seek 到偏移量。
• 缺点：必须预估最大长度，不够灵活。

让我们写个类来封装它。这展示了“资深工程师”的功力：封装底层细节，提供高层接口。

<?php
class SharedMemoryKV {
    private $shm_id;
    private $shm_size;

    // 内存配置
    private const KEY_OFFSET = 0;
    private const VALUE_OFFSET = 32;
    private const TTL_OFFSET = 132;
    private const MAX_KEY_LEN = 32;
    private const MAX_VAL_LEN = 100;
    private const CHUNK_SIZE = 166; // 32 + 100 + 4

    public function __construct($key, $size) {
        // 尝试打开，如果不存在则创建
        $this->shm_id = shmop_open($key, 'c', 0644, $size);
        if (!$this->shm_id) {
            throw new Exception("Cannot open shared memory");
        }
        $this->shm_size = $size;
    }

    /**
     * 设置值
     */
    public function set($key, $value, $ttl = 3600) {
        // 1. 查找空闲槽位（这里简化处理：每次从头覆盖，实际生产环境需要维护空闲链表）
        // 2. 锁（下节课讲）

        $key = substr($key, 0, self::MAX_KEY_LEN); // 截断键名
        $value = substr($value, 0, self::MAX_VAL_LEN); // 截断值

        $buffer = pack('a' . self::MAX_KEY_LEN . 'a' . self::MAX_VAL_LEN . 'I', $key, $value, time() + $ttl);

        // 写入数据
        shmop_write($this->shm_id, $buffer, 0);
    }

    /**
     * 获取值
     */
    public function get($key) {
        // 1. 锁
        // 2. 读取整个块
        $buffer = shmop_read($this->shm_id, 0, $this->shm_size);

        // 3. 解包数据
        $data = unpack('a' . self::MAX_KEY_LEN . 'key/a' . self::MAX_VAL_LEN . 'val/Ittl', $buffer);

        // 4. 检查 TTL
        if (time() > $data['ttl']) {
            return null; // 过期
        }

        // 5. 检查键是否匹配
        // 注意：pack 后末尾会有空字符，需要 trim
        if (trim($data['key']) === $key) {
            return trim($data['val']);
        }

        return null;
    }
}

// 使用示例
$cache = new SharedMemoryKV('my_test_kv', 1024); // 开启一块 1KB 的内存

$cache->set('user:1', 'Tom', 60);
echo "Set user:1 to Tomn";

echo "Get user:1: " . $cache->get('user:1') . "n"; // 输出: Tom
echo "Get user:2: " . $cache->get('user:2') . "n"; // 输出: (null)

看懂了吗？这里用到了 pack 和 unpack。这是 PHP 操作二进制数据的核心 API。pack('a32', $string) 会把字符串填充到 32 字节并补空格。这样我们就可以在内存里像 C 语言一样操作数据了。

性能对比：
Redis 存取一个 String，大概耗时 0.1ms（包含网络）。
上面的 SharedMemory 存取，大概耗时 0.001ms。快了整整两个数量级！

---

第五课：并发就是一场“抢椅子”的游戏

但是，如果我在写入数据的时候，另一个 PHP 进程正在读取数据，或者两个进程都在写，会发生什么？

比如，进程 A 写入 “Hello”，进程 B 同时写入 “World”。最终内存里可能变成 “Hel” + “lo” + “Wo” + “rld” 的乱码。

这就需要锁。

在 Linux 中，我们有 sysvmsg (消息队列), sem (信号量), flock (文件锁)。

对于共享内存，最合适的是 System V 信号量。

5.1 引入信号量

$sem_id = sem_get(12345); // 获取或创建一个信号量 ID
sem_acquire($sem_id);     // 加锁（获取信号量）
// ... 执行临界区操作（读写内存） ...
sem_release($sem_id);     // 解锁

实战代码（加锁的 KV）：

public function set($key, $value, $ttl = 3600) {
    $sem_id = sem_get(12345);
    sem_acquire($sem_id); // 嘘！大家安静，我现在要改桌子上的书了

    // ... 之前的 pack 和 write 代码 ...
    $buffer = pack('a32a100I', substr($key,0,32), substr($value,0,100), time()+$ttl);
    shmop_write($this->shm_id, $buffer, 0);

    sem_release($sem_id); // 好了，写完了，你们可以看了！
}

public function get($key) {
    $sem_id = sem_get(12345);
    sem_acquire($sem_id); // 嘘！我要看书了，别动！

    // ... 之前的 read 代码 ...
    $buffer = shmop_read($this->shm_id, 0, $this->shm_size);
    $data = unpack('a32key/a100val/Ittl', $buffer);

    sem_release($sem_id);

    return (time() > $data['ttl']) ? null : trim($data['val']);
}

这看起来没问题？错！大错特错！

为什么？
因为 shmop_read 是阻塞的！如果在读取的时候，写入者拿到了锁，拼命往里写，那么读取者就会卡住，一直等到写入者释放锁。

更好的做法是：写加独占锁，读加共享锁。

或者更简单粗暴但有效的策略：写加锁，读加锁（读的时候也把内存锁住，防止读到一半数据被改）。虽然牺牲了一点并发读，但在高并发写环境下，这是安全的。对于简单的统计缓存，这种牺牲是值得的。

---

第六课：真正的杀手锏——实现一个实时 API 监控系统

光说概念太枯燥。我们来做一个真正能落地、且非常有价值的项目：基于共享内存的实时 API 耗时监控系统。

这个场景非常适合用共享内存：

1. HTTP 请求进来了：记录开始时间戳。
2. 请求处理完了：计算耗时，写入共享内存。
3. 运维/大屏页面请求来了：从共享内存读取这些数据，计算出平均耗时、P99 耗时。

6.1 架构设计

• 写进程：你的 PHP-FPM 或者 CLI 脚本。
• 内存结构：
  • 假设我们记录最近 1000 个请求。
  • 每个记录 24 字节（4字节时间戳 + 4字节开始时间 + 4字节结束时间 + 4字节耗时 + 8字节预留）。
  • 总共需要 24KB 内存。非常小！

6.2 核心代码实现

1. 定义共享内存管理类

class ApiMonitor {
    private $shm_id;
    private $record_size = 24; // int32 3个 + int64 1个
    private $max_records = 1000;
    private $total_size;
    private $sem_id;

    public function __construct($key = 'api_monitor') {
        $this->total_size = $this->record_size * $this->max_records;
        $this->shm_id = shmop_open($key, 'c', 0644, $this->total_size);
        $this->sem_id = sem_get($key . '_sem');

        // 初始化内存为 0
        shmop_write($this->shm_id, str_repeat("x00", $this->total_size), 0);
    }

    /**
     * 记录请求开始
     */
    public function start($api_name) {
        $sem_id = sem_get($this->sem_id);
        sem_acquire($sem_id);

        // 这里我们简化，不存 API 名称，只存耗时数据
        // 实际上你可以用哈希表结构存名字
        $timestamp = time();
        $start_time = microtime(true);

        // 找到空闲槽位（简单的环形队列实现）
        // 这里为了演示简化，每次覆盖第一个位置，实际应用需要维护 head 和 tail 指针

        $record = pack('Iddd', $timestamp, $start_time, 0);
        shmop_write($this->shm_id, $record, 0); // 写入头部

        sem_release($sem_id);
        return $start_time;
    }

    /**
     * 记录请求结束
     */
    public function end($start_time) {
        $sem_id = sem_get($this->sem_id);
        sem_acquire($sem_id);

        // 读取刚才写入的数据（因为内存是连续的，读取头部就是刚才写入的数据）
        $buffer = shmop_read($this->shm_id, 0, $this->record_size);
        $data = unpack('Its/Ist/Idur', $buffer);

        $end_time = microtime(true);
        $duration = ($end_time - $data['ist']) * 1000; // 毫秒

        // 更新耗时
        $new_record = pack('Iddd', $data['ts'], $data['ist'], $duration);
        shmop_write($this->shm_id, $new_record, 0);

        sem_release($sem_id);
        return $duration;
    }

    /**
     * 获取统计数据（读端）
     */
    public function getStats() {
        $sem_id = sem_get($this->sem_id);
        sem_acquire($sem_id);

        $buffer = shmop_read($this->shm_id, 0, $this->record_size);
        $data = unpack('Its/Ist/Idur', $buffer);

        sem_release($sem_id);

        return [
            'timestamp' => $data['ts'],
            'duration'  => $data['dur'],
            'start'     => $data['ist'],
        ];
    }
}

2. 在你的业务代码中集成

想象你在 index.php 的最开始和结尾加上这两行：

// 1. 在业务开始前
$monitor = new ApiMonitor();
$startTime = $monitor->start();

// ... 你的业务逻辑 ... 比如 $db->query("SELECT * FROM users") ...

// 2. 在业务结束后
$duration = $monitor->end($startTime);
echo "本次请求耗时: {$duration} ms";

3. 创建一个监控查看页面

// monitor.php
$monitor = new ApiMonitor();
$stats = $monitor->getStats();

echo "<h1>实时监控</h1>";
echo "<p>最近一次请求耗时: <strong>{$stats['duration']} ms</strong></p>";
echo "<p>开始时间: " . date('Y-m-d H:i:s', $stats['timestamp']) . "</p>";

效果：
当你疯狂刷新 monitor.php 时，你会看到实时的毫秒级耗时波动。这一切不需要网络通信，没有 Redis 的压力，甚至没有磁盘 IO。CPU 的消耗仅仅是 unpack 和 pack。

---

第七课：坑在哪里？避坑指南

作为资深工程师，我不能只给你糖果，还要给你药方。共享内存有很多坑，如果你不注意，你的生产环境会出大乱子。

1. 进程重启导致的“幽灵数据”

PHP-FPM 优雅重启或者崩溃重启时，变量会丢失。但是 shmop_open 创建的共享内存块默认是持久化的！

• 后果：重启后，旧的数据还在，新进程直接读取到过期数据，导致逻辑错误。
• 对策：
  • 如果是 FPM 模式，重启前必须调用 shmop_delete。
  • 或者，每次启动时，先检查内存里的数据是否有效，无效则清零。

2. 内存泄漏

如果你在代码里写了 $data = shmop_read(...)，但是这个 $data 变量一直没被释放（虽然 PHP GC 会回收变量，但内存占用是连续的），如果频繁读写，可能会导致内存一直被占用。

• 对策：养成好习惯，用完读出来的数据，不要一直挂在外面。

3. 锁的死锁

如果 PHP-FPM 进程在持有锁（sem_acquire）的情况下崩溃了，锁永远不会被释放。

• 后果：所有依赖这块内存的其他进程（监控脚本、定时任务）全部卡死，直到 PHP-FPM 重启。
• 对策：尽量避免在持有锁的情况下做耗时操作。上面的例子中，读操作很快，所以没事。但如果读操作涉及到复杂的逻辑计算，请务必在锁外进行。

4. 序列化的陷阱

很多人为了省事，想直接把 PHP 对象序列化存进去。

$data = serialize(['a'=>1, 'b'=>2]);
shmop_write($shm, $data, 0);

虽然这能用，但序列化后的字符串里会有很多不可见的控制字符（如 ），导致二进制对齐变得非常复杂，而且容易因为边界问题读错数据。记住：在共享内存里，永远用 pack/unpack 和二进制协议，不要用 serialize。

---

第八课：Redis 真的没用了吗？

写到这里，可能有些同学会说：“这东西这么好，我是不是不用买 Redis 服务器了？”

千万别！

共享内存是极度脆弱的。

1. 容量受限：你只能存几 MB 到几百 MB 的数据。Redis 是 GB 级别的。
2. 不可持久化：一旦断电，内存里什么都没了。
3. 跨进程难：Redis 是网络协议，任何语言都能连。共享内存是操作系统层面的，只有同一个 OS 里的进程才能共享。

我的建议：

混合策略。

• Redis：作为你的“中央大仓库”。存配置、存复杂的 Hash 结构、存 Session、存需要跨服务器共享的数据。
• 共享内存：作为你的“贴身秘书”。存高频读取、高并发写入、对延迟极度敏感的临时数据。

举个例子：

• 用户在线状态：如果存 Redis，网络开销大。如果用共享内存，多个 PHP 进程瞬间就能判断出用户是否在线。
• 热点计数器：比如直播间的人数统计。Redis 每秒要处理几万次 INCR，虽然 Redis 很强，但如果那个计数器只是用来展示给前端看的，共享内存足以应对百万级的并发。

---

第九课：进阶玩法——实现一个轻量级消息队列

共享内存除了存数据，还可以做消息队列（MQ）。这可是高并发架构的标配。

原理：
内存里放一个数组（模拟）。一个进程往里塞数据，一个进程往外拿数据。

简单实现（不包含锁，演示用）：

// 生产者
function producer($key, $msg) {
    $shm = shmop_open($key, 'c', 0644, 10240);
    $buffer = shmop_read($shm, 0, 10240);
    // 简单起见，直接追加到末尾，不处理越界
    $offset = strlen($buffer);
    shmop_write($shm, $msg . "n", $offset);
}

// 消费者
function consumer($key) {
    $shm = shmop_open($key, 'w', 0644, 10240); // 'w' 模式允许读写
    $buffer = shmop_read($shm, 0, 10240);
    $lines = explode("n", $buffer);

    foreach ($lines as $line) {
        if (!empty($line)) {
            echo "Processed: " . $line . "n";
        }
    }
    // 清空队列
    shmop_write($shm, str_repeat("", 10240), 0);
}

这叫“生产者-消费者模型”。在 PHP 中，你可以用 pcntl_fork 开启两个子进程，一个做生产者，一个做消费者，实现纯内存的异步任务处理，速度比 RabbitMQ 快 100 倍，但功能比 RabbitMQ 弱。

---

第十课：总结与展望

好了，同学们，今天的讲座要结束了。

我们回顾一下今天的内容：

1. 痛点：网络延迟和序列化开销是隐藏的杀手。
2. 方案：使用 shmop 扩展在 PHP 进程间共享内存。
3. 核心技能：掌握 pack 和 unpack 进行二进制数据读写。
4. 关键点：必须使用信号量（sem_*）来保证并发安全。
5. 适用场景：高频缓存、实时监控、临时数据交换。

最后送大家一句话：
技术选型没有绝对的对错，只有适不适合。Redis 是一个强大的系统，但有时候，你只需要一个能在内存里贴张便签的便利贴。

当你下一次面对一个高并发、低延迟要求的任务时，试着想一想：是不是真的需要绕地球一圈去读个缓存？能不能直接伸进桌子底下拿？

希望今天的分享能让你在 PHP 的世界里，多一种“降维打击”的武器。去试试吧，记得先在测试环境跑，别在生产环境直接干掉 Redis——除非你真的准备好了处理那些棘手的并发 Bug。

谢谢大家！