Resmic's | BLOG

PHP 8.4 新特性全解析：属性钩子、非对称可见性与HTML5解析器实战

Sun, 17 May 2026 08:07:36 +0800

一、PHP 8.4 重大升级概览

PHP 8.4 于 2024 年 11 月正式发布，是 PHP 近年来功能最丰富的版本之一。本次更新引入了属性钩子（Property Hooks）、非对称可见性（Asymmetric Visibility）、全新的 HTML5 解析器以及大量数组操作函数，大幅提升了开发效率与语言表达力。

本文将深入剖析 PHP 8.4 的核心新特性，配合完整代码示例，帮助你快速掌握并应用于实际项目中。

二、属性钩子（Property Hooks）：告别冗余 Getter/Setter

属性钩子是 PHP 8.4 最受关注的特性，灵感来自 C# 和 Kotlin。它允许在属性定义时直接内联逻辑，无需手动编写大量 getter/setter 方法。

<?php

class User {
    public string $fullName {
        get {
            return $this->firstName . ' ' . $this->lastName;
        }
    }

    public string $email {
        get => strtolower($this->_email);
        set {
            if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                throw new \InvalidArgumentException("Invalid email: $value");
            }
            $this->_email = $value;
        }
    }

    public function __construct(
        public string $firstName,
        public string $lastName,
        private string $_email = '',
    ) {}
}

$user = new User('张', '伟');
$user->email = 'zhang@example.com';
echo $user->fullName;  // 张 伟
echo $user->email;     // zhang@example.com

属性钩子支持 get 和 set 两种形式，可单独使用也可组合，简洁箭头语法 get => 适用于单行表达式。

三、非对称可见性（Asymmetric Visibility）

PHP 8.4 新增了属性读写分离的可见性控制，让你可以对外公开读取、对内限制写入，实现更优雅的封装。

<?php

class BankAccount {
    // 公开读取，私有写入
    public private(set) float $balance = 0.0;

    // 公开读取，protected 写入
    public protected(set) string $ownerId;

    public function __construct(string $ownerId) {
        $this->ownerId = $ownerId;
    }

    public function deposit(float $amount): void {
        if ($amount <= 0) throw new \InvalidArgumentException('Amount must be positive');
        $this->balance += $amount;  // 内部可写
    }

    public function withdraw(float $amount): void {
        if ($amount > $this->balance) throw new \RuntimeException('Insufficient funds');
        $this->balance -= $amount;
    }
}

$account = new BankAccount('user_001');
$account->deposit(1000.0);
echo $account->balance;    // 1000.0 — 可读
// $account->balance = 9999;  // Fatal Error — 外部不可写

这一特性彻底解决了以往需要写一堆 getBalance() 方法的问题，代码更干净，意图更明确。

public private(set)：任何地方可读，仅当前类可写
public protected(set)：任何地方可读，当前类和子类可写
protected private(set)：子类可读，仅当前类可写

四、全新数组操作函数

PHP 8.4 新增了一批非常实用的数组函数，减少了许多常见场景中的模板代码。

4.1 array_find 与 array_find_key

<?php

$users = [
    ['id' => 1, 'name' => '张三', 'role' => 'admin'],
    ['id' => 2, 'name' => '李四', 'role' => 'editor'],
    ['id' => 3, 'name' => '王五', 'role' => 'admin'],
];

// array_find：返回第一个满足条件的元素值
$admin = array_find($users, fn($u) => $u['role'] === 'admin');
// ['id' => 1, 'name' => '张三', 'role' => 'admin']

// array_find_key：返回第一个满足条件的键名
$key = array_find_key($users, fn($u) => $u['name'] === '李四');
// 1

// array_any：只要有一个满足就返回 true
$hasAdmin = array_any($users, fn($u) => $u['role'] === 'admin');  // true

// array_all：所有元素满足才返回 true
$allActive = array_all($users, fn($u) => isset($u['id']));  // true

4.2 array_zip 与更多组合技

<?php

// 实用组合：找出所有 admin 的名字
$adminNames = array_map(
    fn($u) => $u['name'],
    array_filter($users, fn($u) => $u['role'] === 'admin')
);
// ['张三', '王五']

// 或使用 array_find + array_map 链式处理
$firstAdminName = array_find($users, fn($u) => $u['role'] === 'admin')['name'] ?? null;
// '张三'

五、全新 HTML5 解析器（基于 Lexbor）

PHP 8.4 引入了基于 Lexbor 的新 HTML5 解析器，通过 Dom\HTMLDocument 和 Dom\XMLDocument 类提供，取代了老旧的 DOMDocument，完全符合 HTML5 规范。

<?php

// 旧方式（PHP 8.3 及之前）
$oldDom = new DOMDocument();
@$oldDom->loadHTML('<p>Hello <b>World</b></p>');

// 新方式（PHP 8.4）
$html = '<!DOCTYPE html><html><body><article id="main"><p>PHP 8.4 <strong>很强！</strong></p></article></body></html>';

$doc = Dom\HTMLDocument::createFromString($html, LIBXML_NOERROR);
$article = $doc->getElementById('main');
echo $article->textContent;  // PHP 8.4 很强！

// 支持 querySelector（CSS 选择器！）
$strong = $doc->querySelector('article strong');
echo $strong->textContent;   // 很强！

$allParagraphs = $doc->querySelectorAll('p');
foreach ($allParagraphs as $p) {
    echo $p->innerHTML . "\n";
}

// 从文件或 URL 加载
$docFromFile = Dom\HTMLDocument::createFromFile('/path/to/page.html');

新解析器支持 querySelector / querySelectorAll CSS 选择器，无需再引入 Symfony DomCrawler 或 phpQuery 等第三方库来做基础 HTML 解析，非常适合爬虫、邮件模板处理、内容抓取等场景。

六、其他值得关注的新特性

6.1 new 表达式不再需要括号

<?php

// PHP 8.3 及之前
$length = (new Collection([1, 2, 3]))->count();

// PHP 8.4：直接链式调用，无需括号包裹
$length = new Collection([1, 2, 3])->count();

// 在方法链中的应用
$result = new QueryBuilder()
    ->table('users')
    ->where('status', 'active')
    ->orderBy('created_at', 'DESC')
    ->get();

6.2 JIT 编译器改进与性能提升

PHP 8.4 对 JIT（Just-In-Time）编译器进行了重大重构，新的 IR（中间表示）框架使 JIT 编译更加稳定高效：

CPU 密集型任务性能提升约 5-10%
JIT 生成代码质量更高，更易于调试
新增 tracing 和 function JIT 模式配置选项
修复了多个 JIT 相关的内存安全问题

6.3 Lazy Objects（惰性对象）

<?php

class DatabaseConnection {
    public function __construct(
        private string $host,
        private int $port,
        private string $dbname,
    ) {
        // 模拟耗时初始化
        echo "Connecting to {$this->host}:{$this->port}/{$this->dbname}\n";
    }

    public function query(string $sql): array { /* ... */ return []; }
}

// 创建惰性代理 — 实际对象尚未初始化
$reflector = new ReflectionClass(DatabaseConnection::class);
$proxy = $reflector->newLazyProxy(function() {
    return new DatabaseConnection('localhost', 3306, 'mydb');
});

// 此时尚未输出 "Connecting to..."
echo "Proxy created\n";

// 只有真正使用时才初始化
$result = $proxy->query('SELECT 1');
// 现在才输出 "Connecting to localhost:3306/mydb"

惰性对象特别适合依赖注入容器、ORM 延迟加载、服务定位器等场景，可以显著减少应用启动时的初始化开销。

七、升级建议与兼容性注意事项

PHP 8.4 虽然功能强大，升级前需关注以下破坏性变更：

隐式 nullable 类型弃用：function foo(Type $x = null) 需改为 function foo(?Type $x = null)，PHP 8.4 发出弃用警告，PHP 9.0 将直接报错
GMP 扩展变更：GMP 对象不再支持动态属性
LDAP 扩展废弃：若干旧 API 标记弃用
MySQLnd 变更：mysqli_ping() 等函数行为调整

升级步骤建议：

在测试环境先用 php -l 批量检查语法兼容性
开启 E_DEPRECATED 日志，修复所有弃用警告
运行完整测试套件（PHPUnit）
使用 Rector 自动化迁移工具处理大量重复修改
灰度上线，监控错误率

PHP 8.4 是一次值得升级的大版本，属性钩子、非对称可见性、新 HTML5 解析器等特性将显著提升代码可读性和开发效率。建议在项目的下一个迭代周期规划升级，早用早受益。

PHP 8.4 核心新特性深度解析：属性钩子、懒加载对象与新增数组函数实战指南

Sat, 16 May 2026 08:10:18 +0800

PHP 8.4 正式发布：为什么值得升级？

PHP 8.4 于 2024 年 11 月正式发布，带来了多项开发者期待已久的语言特性。这次升级延续了 PHP 8.x 系列的现代化步伐，让 PHP 在类型系统、面向对象设计和运行时性能等维度都有了质的提升。

如果你还在使用 PHP 8.1 或 8.2，现在正是评估升级的好时机。本文将用实际代码示例带你快速了解最值得关注的新特性。

属性钩子（Property Hooks）：告别繁琐的 getter/setter

这是 PHP 8.4 最受期待的特性之一。过去我们需要为每个属性手写 getXxx() 和 setXxx() 方法，代码冗余且难以维护。属性钩子让你直接在属性声明处定义读写逻辑：

class User {
    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
        set(string $value) {
            [$this->firstName, $this->lastName] = explode(' ', $value, 2);
        }
    }

    public function __construct(
        public string $firstName,
        public string $lastName
    ) {}
}

$user = new User('张', '三');
echo $user->fullName;      // 输出：张 三
$user->fullName = '李 四'; // 自动分割
echo $user->firstName;     // 输出：李

属性钩子同样支持接口定义，这意味着你可以在接口层面约束钩子行为，大幅提升代码的可维护性。

懒加载对象（Lazy Objects）：按需初始化的优雅方案

PHP 8.4 在反射 API 中引入了懒加载对象支持，非常适合依赖注入容器、ORM 延迟加载等场景：

class DatabaseConnection {
    public function __construct(
        private string $dsn,
        private string $username,
        private string $password
    ) {
        // 假设这里有耗时的初始化操作
        echo "连接数据库中...\n";
    }

    public function query(string $sql): array {
        return []; // 实际查询逻辑
    }
}

// 创建懒加载对象——此时构造函数尚未执行
$reflector = new ReflectionClass(DatabaseConnection::class);
$db = $reflector->newLazyGhost(function (DatabaseConnection $obj) {
    $obj->__construct('mysql:host=localhost', 'root', 'secret');
});

echo "对象已创建，但未初始化\n";
// 只有真正使用时才触发初始化
$result = $db->query('SELECT 1');
echo "现在才连接数据库\n";

懒加载对象分为 Ghost 和 Proxy 两种模式，Ghost 模式直接初始化原对象，Proxy 模式则创建代理实例，各有适用场景。

新增数组函数：array_find / array_find_key / array_any / array_all

这四个新函数填补了 PHP 数组操作的长期空白，终于不用再写重复的 foreach 查找逻辑了：

$users = [
    ['name' => '张三', 'age' => 28, 'active' => true],
    ['name' => '李四', 'age' => 35, 'active' => false],
    ['name' => '王五', 'age' => 22, 'active' => true],
];

// array_find：找到第一个匹配元素
$adult = array_find($users, fn($u) => $u['age'] >= 30);
// ['name' => '李四', 'age' => 35, 'active' => false]

// array_find_key：找到第一个匹配元素的键
$key = array_find_key($users, fn($u) => !$u['active']);
// 1

// array_any：是否存在至少一个匹配元素
$hasActive = array_any($users, fn($u) => $u['active']);
// true

// array_all：是否所有元素都匹配
$allActive = array_all($users, fn($u) => $u['active']);
// false

array_find：类似 JavaScript 的 Array.prototype.find()
array_find_key：返回匹配元素的键而非值
array_any：等价于 JS 的 some()
array_all：等价于 JS 的 every()

其他值得关注的改进

PHP 8.4 还包含了若干实用的小改进，提升日常开发体验：

new 不再需要括号：$obj = new Foo()->method() 现在合法，链式调用更流畅
#[\Deprecated] 属性：可用于标记类、方法、常量为废弃，触发标准废弃警告
BCMath 对象 API：新增 BcMath\Number 类，支持运算符重载，让高精度计算代码更直观
HTML5 解析器：Dom\HTMLDocument 基于最新 HTML5 规范，替代旧的 DOMDocument
PDO Driver 特定子类：PDO::connect() 现在直接返回 Pdo\Mysql/Pdo\Sqlite 等子类，类型更精确

// new 不再需要括号示例
$length = new Stringable('hello world')->length(); // 假设有此方法

// Deprecated 属性标记
class LegacyApi {
    #[\Deprecated('请使用 newMethod()')]
    public function oldMethod(): void {}
}

// BCMath 对象 API
use BcMath\Number;
$a = new Number('10.5');
$b = new Number('3.2');
$result = $a + $b;  // 运算符重载，结果为 Number('13.7')
echo $result;       // 13.7

升级建议与兼容性注意事项

PHP 8.4 的不兼容变更相对较少，升级成本低。主要需要关注：

隐式 nullable 类型已废弃：function foo(string $x = null) 需改为 ?string $x = null
E_STRICT 常量已移除：若代码中有 E_STRICT 引用需清理
部分 LDAP 函数已移除：检查是否使用了废弃的 LDAP 函数

升级步骤建议：先在测试环境运行 php -l 语法检测，再用 PHPStan 或 Rector 的规则集做静态分析，识别废弃用法后再切换生产环境。

总体而言，PHP 8.4 是一次高质量的版本迭代，属性钩子和懒加载对象尤其值得在新项目中积极采用，能显著提升代码的可读性和设计质量。

PHP 8.3 新特性全面解析：类型系统、随机数API与性能优化实战

Fri, 15 May 2026 08:09:29 +0800

PHP 8.3 概览：值得升级的理由

PHP 8.3 于 2023 年 11 月正式发布，作为 PHP 8.x 系列的最新稳定版本，它在语言特性、类型系统和性能方面都带来了显著改进。如果你还在使用 PHP 8.0 或 8.1，现在是时候认真考虑迁移到 8.3 了。

相比早期版本，PHP 8.3 在以下几个核心方向取得了突破：

类型系统增强：类型化类常量（Typed Class Constants）让代码更严谨
只读属性改进：支持对只读属性进行初始化再赋值（Clone 场景）
新的随机数 API：Randomizer 类提供更安全、可测试的随机数生成
动态类常量获取：支持通过变量访问类常量
性能提升：OPcache 优化，实测吞吐量提升 5%-10%

下面我们逐一深入讲解这些特性，并结合真实项目场景给出最佳实践。

类型化类常量：让接口契约更严格

在 PHP 8.3 之前，类常量没有类型约束，容易出现意外的类型混用。8.3 引入了类型化类常量（Typed Class Constants），让常量拥有明确的类型声明。

<?php
// PHP 8.3 之前：常量无类型限制
class Status {
    const ACTIVE = 1;       // int
    const LABEL  = 'active'; // 与 ACTIVE 语义无关联
}

// PHP 8.3：类型化类常量
class Status {
    const int    ACTIVE   = 1;
    const string LABEL    = 'active';
    const float  VERSION  = 8.3;
    const bool   IS_VALID = true;
}

// 接口中也支持类型化常量
interface Configurable {
    const string DEFAULT_LOCALE = 'zh-CN';
    const int    MAX_RETRY      = 3;
}

class App implements Configurable {
    // 实现必须匹配类型，否则抛出 TypeError
    const string DEFAULT_LOCALE = 'en-US'; // ✅ 合法
    const int    MAX_RETRY      = 5;        // ✅ 合法
}

类型化常量的好处在于：继承类如果试图用不兼容的类型覆盖父类常量，PHP 会在编译阶段直接报错，而不是等到运行时才暴露问题。

<?php
class Base {
    const int LIMIT = 100;
}

class Child extends Base {
    const string LIMIT = 'unlimited'; // Fatal error: 类型不兼容
}

在大型项目中，建议将所有业务枚举常量都加上类型声明，这样 IDE 和静态分析工具（PHPStan、Psalm）可以提供更精准的检查。

只读属性增强：克隆场景的解决方案

PHP 8.1 引入了只读属性（readonly），但有一个痛点：只读属性一旦初始化就无法修改，导致克隆对象时无法更新属性值。PHP 8.3 通过允许在克隆（clone）操作中重新赋值来解决这个问题。

<?php
class User {
    public function __construct(
        public readonly int    $id,
        public readonly string $name,
        public readonly string $email,
    ) {}
}

$user = new User(1, '张三', 'zhangsan@example.com');

// PHP 8.3 之前：无法修改只读属性，这种需求只能放弃使用 readonly
// $updated = clone $user; // clone 后无法改 email

// PHP 8.3：使用 clone with 语法修改只读属性
$updated = clone($user, email: 'new@example.com'); // 未来语法提案
// 目前实际可用的方式：在 __clone 中通过特定模式重置

更实用的场景是结合值对象（Value Object）模式：

<?php
// 推荐模式：使用 with 方法返回新实例
class Money {
    public function __construct(
        public readonly int    $amount,
        public readonly string $currency,
    ) {}

    public function withAmount(int $amount): static {
        $clone = clone $this;
        // PHP 8.3 允许在 clone 上下文中对 readonly 属性赋值
        $clone->amount = $amount;
        return $clone;
    }
}

$price  = new Money(100, 'CNY');
$double = $price->withAmount(200);
echo $double->amount;   // 200
echo $price->amount;    // 100 — 原对象不变

这让不可变数据对象（Immutable DTO）的实现变得自然，无需再为了可克隆性而放弃 readonly。

新随机数 API：安全、可测试的随机性

PHP 8.2 引入了 Random\Randomizer 类，8.3 进一步完善了相关 API，包括新增 getBytesFromString()、nextFloat() 等方法，让随机数生成更灵活、更易于单元测试。

<?php
use Random\Randomizer;
use Random\Engine\Mt19937;
use Random\Engine\Secure;

// 生产环境：使用密码学安全引擎
$randomizer = new Randomizer(new Secure());

// 生成随机字节
$token = bin2hex($randomizer->getBytes(32));
echo $token; // 64位十六进制随机 token

// PHP 8.3 新增：从指定字符集中取随机字节
$charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$code    = $randomizer->getBytesFromString($charset, 8);
echo $code; // 例如：aB3kR7mX

// 生成范围内随机浮点数 (PHP 8.3 新增)
$float = $randomizer->nextFloat();         // [0.0, 1.0)
$float = $randomizer->getFloat(1.5, 9.5);  // [1.5, 9.5]

// 打乱数组
$items    = ['A', 'B', 'C', 'D', 'E'];
$shuffled = $randomizer->shuffleArray($items);

// 单元测试：使用固定种子保证可重复性
$seeded = new Randomizer(new Mt19937(42));
$result = $seeded->getInt(1, 100); // 固定种子，每次结果相同，便于测试

传统的 rand()、mt_rand() 不适合安全场景（如生成 token、验证码），而 random_bytes() 虽然安全但功能有限。新的 Randomizer API 既安全又灵活，是未来的最佳选择。

动态类常量获取与 json_validate 函数

PHP 8.3 支持通过变量动态访问类常量，告别了以前需要借助 constant() 函数的繁琐写法。

<?php
class Color {
    const string RED   = '#FF0000';
    const string GREEN = '#00FF00';
    const string BLUE  = '#0000FF';
}

// PHP 8.3 之前
$name  = 'RED';
$value = constant('Color::' . $name); // 需要用 constant()

// PHP 8.3：直接使用变量
$name  = 'GREEN';
$value = Color::{$name}; // '#00FF00' ✓

// 在枚举中同样适用
enum Direction {
    case North;
    case South;
    case East;
    case West;
}

$dir   = 'North';
$value = Direction::{$dir}; // Direction::North

另一个非常实用的新增函数是 json_validate()，它仅验证 JSON 字符串是否合法，而不进行解析，性能比 json_decode() + 错误检查高得多：

<?php
// PHP 8.3 之前：验证 JSON 需要先解码
function isValidJson(string $str): bool {
    json_decode($str);
    return json_last_error() === JSON_ERROR_NONE;
}

// PHP 8.3：直接用 json_validate()
$validJson   = '{"name":"张三","age":30}';
$invalidJson = '{name:张三}';

var_dump(json_validate($validJson));   // bool(true)
var_dump(json_validate($invalidJson)); // bool(false)

// 支持指定最大嵌套深度
json_validate($validJson, depth: 5);  // 最多5层嵌套

// 实际场景：API 入参校验
function handleApiRequest(string $body): array {
    if (!json_validate($body)) {
        throw new InvalidArgumentException('请求体不是合法的 JSON');
    }
    return json_decode($body, true);
}

性能优化与迁移实践

PHP 8.3 在底层做了多项性能优化，主要体现在：

OPcache 改进：改进了类型推断，生成更优化的字节码
JIT 稳定性提升：修复了多个 JIT 相关 bug，对计算密集型应用提升明显
内存使用优化：减少了字符串拷贝次数，降低了常见操作的内存开销
Fiber 改进：协程相关功能更稳定，适合高并发异步场景

从 PHP 8.1/8.2 迁移到 8.3 的步骤：

# 1. 检查当前 PHP 版本
php -v

# 2. 用 PHP Compatibility Checker 扫描代码
composer require --dev phpcompatibility/php-compatibility
vendor/bin/phpcs --standard=PHPCompatibility --runtime-set testVersion 8.3 src/

# 3. 运行测试套件
composer test

# 4. 检查废弃警告（升级前先修复所有 Deprecated）
php -d error_reporting=E_ALL index.php 2>&1 | grep -i deprecated

# 5. 更新 Docker 基础镜像
# FROM php:8.2-fpm → FROM php:8.3-fpm

值得注意的废弃变更：

ldap_connect() 不再支持 host:port 格式，需拆分参数
部分 DateTime 构造器行为调整，建议使用 DateTimeImmutable
str_pad() 对多字节字符串的处理更严格，注意中文场景

总体来说，PHP 8.3 的迁移成本极低，而收益显著。无论是代码质量、开发体验还是运行性能，都值得尽早升级。现在就把 composer.json 中的 "php": ">=8.1" 改为 "php": ">=8.3"，开始享受新特性吧！

Jetpack Compose 性能优化实战：从重组原理到 60fps 实践指南

Thu, 14 May 2026 08:08:40 +0800

Jetpack Compose 自正式发布以来，已成为 Android 声明式 UI 开发的标准选择。然而随着项目规模增大，许多开发者开始遭遇 Compose 的性能问题：卡顿、掉帧、不必要的重组（Recomposition）。本文从底层原理出发，系统讲解如何排查和优化 Compose 的渲染性能，帮助你将帧率稳定在 60fps 甚至 120fps。

一、理解 Compose 的渲染三阶段

要优化性能，首先要理解 Compose 的渲染流程。Compose 将 UI 渲染分为三个阶段：

Composition（组合）：执行 Composable 函数，构建 UI 树（Slot Table）
Layout（布局）：测量每个节点的尺寸与位置，单次遍历即可完成（相比 View 避免多次测量）
Drawing（绘制）：将布局结果绘制到画布（Canvas）上

理解这三个阶段的关键点：不是每次 State 变化都会触发完整的三阶段。Compose 有一套智能跳过机制——如果某个 Composable 的输入没有变化，它可以被跳过（skipped）。这个跳过机制是性能优化的核心。

// Compose 内部的跳过判断逻辑示意
// 如果所有参数都 "stable" 且值没变化，则跳过重组
@Composable
fun UserCard(user: User) { // User 如果是 data class，默认 stable
    Text(text = user.name)
    Text(text = user.email)
}

二、重组（Recomposition）的陷阱与优化策略

不必要的重组是 Compose 性能问题的头号原因。以下是常见的重组陷阱：

陷阱1：Lambda 捕获导致重组扩散

// ❌ 错误写法：每次父组件重组，onClick 都是新的 Lambda 实例
@Composable
fun ParentComposable(items: List<Item>) {
    items.forEach { item ->
        ItemRow(item = item, onClick = { doSomething(item) })
    }
}

// ✅ 正确写法：使用 remember 缓存 Lambda
@Composable
fun ParentComposable(items: List<Item>) {
    items.forEach { item ->
        val onClick = remember(item.id) { { doSomething(item) } }
        ItemRow(item = item, onClick = onClick)
    }
}

陷阱2：unstable 类导致无法跳过

// ❌ List<T> 被 Compose 认为是 unstable（因为它是 MutableList 的接口）
@Composable
fun ItemList(items: List<String>) { ... }

// ✅ 方案1：使用 @Stable 或 @Immutable 注解包装
@Immutable
data class ImmutableList<T>(val items: List<T>)

// ✅ 方案2：使用 kotlinx.collections.immutable
implementation("org.jetbrains.kotlinx:kotlinx-collections-immutable:0.3.7")

@Composable
fun ItemList(items: ImmutableList<String>) { ... }

陷阱3：读取 State 的位置影响重组范围

将 State 的读取尽可能下移到最小的 Composable 范围内，是减少重组范围的关键技巧。

// ❌ 在父级读取 State，导致整个父组件重组
@Composable
fun Screen(viewModel: MyViewModel) {
    val uiState by viewModel.uiState.collectAsState()
    Column {
        Header(title = uiState.title)    // 只有这里需要 title
        Body(content = uiState.content)  // 只有这里需要 content
    }
}

// ✅ 将 State 读取下移，各子组件独立重组
@Composable
fun Screen(viewModel: MyViewModel) {
    Column {
        Header(titleFlow = viewModel.titleFlow)
        Body(contentFlow = viewModel.contentFlow)
    }
}

三、使用 Compose 编译器报告分析重组

光靠肉眼审查代码很低效，Compose 编译器提供了强大的报告工具，可以直接告诉你哪些 Composable 是 restartable、skippable 或 unstable 的。

开启编译器报告

// build.gradle.kts (app 模块)
android {
    kotlinOptions {
        freeCompilerArgs += listOf(
            "-P",
            "plugin:androidx.compose.compiler.plugins.kotlin:reportsDestination=${project.buildDir.absolutePath}/compose_reports"
        )
        freeCompilerArgs += listOf(
            "-P",
            "plugin:androidx.compose.compiler.plugins.kotlin:metricsDestination=${project.buildDir.absolutePath}/compose_metrics"
        )
    }
}

编译后在 build/compose_reports/ 目录下会生成报告文件，其中 *-composables.txt 列出每个 Composable 的稳定性分析：

restartable skippable scheme("[0, 65536]") fun UserCard(
  stable user: User
)

restartable scheme("[0, 65536]") fun OrderList(
  unstable orders: List<Order>  // ⚠️ 这里！无法被跳过
)

使用 Layout Inspector 实时观测重组

Android Studio 的 Layout Inspector 支持 Compose，可以实时高亮哪些 Composable 正在重组，并显示重组次数。开启路径：View → Tool Windows → Layout Inspector，选中 App Process 后勾选"Show Recomposition Counts"。

四、LazyList 性能优化：避免常见的 100ms 卡顿

LazyColumn / LazyRow 是 Compose 中最常用的列表组件，也是最容易踩坑的地方。

1. key 参数：避免无效的 item 重组

// ❌ 没有 key，数据变化时所有 item 都可能重组
LazyColumn {
    items(items) { item ->
        ItemCard(item)
    }
}

// ✅ 指定稳定的 key，Compose 只重组真正变化的 item
LazyColumn {
    items(items, key = { it.id }) { item ->
        ItemCard(item)
    }
}

2. contentType：加速 item 复用

// 当列表有多种类型时，指定 contentType 可以提高复用效率
LazyColumn {
    items(
        items = feedItems,
        key = { it.id },
        contentType = { it.type } // "post", "ad", "story" 等
    ) { item ->
        when (item.type) {
            "post" -> PostCard(item)
            "ad" -> AdBanner(item)
            else -> StoryCard(item)
        }
    }
}

3. 预加载更多内容（prefetchDistance）

// 自定义 LazyListState 的预加载距离
val state = rememberLazyListState()
val prefetchState = rememberLazyListPrefetchState(
    prefetchScheduler = AsyncPrefetchScheduler()
)
LazyColumn(
    state = state,
    prefetchState = prefetchState
) { ... }

4. 避免在 LazyList 中嵌套滚动列表

在 LazyColumn 中嵌套 LazyRow 时，内层 LazyRow 的高度必须固定，否则会导致无限高度测量异常：

LazyColumn {
    item {
        LazyRow(
            modifier = Modifier.height(120.dp) // ✅ 必须固定高度
        ) {
            items(horizontalItems) { ItemChip(it) }
        }
    }
}

五、状态管理对性能的影响

不合理的状态管理会让本可避免的重组频繁发生。

优先选择细粒度 State 而非大对象

// ❌ 一个大的 data class State，任何字段变化都触发全量重组
data class ScreenState(
    val title: String,
    val isLoading: Boolean,
    val items: List<Item>,
    val errorMsg: String?
)
val state by viewModel.screenState.collectAsState()

// ✅ 拆分 State，按需收集
val title by viewModel.title.collectAsState()
val isLoading by viewModel.isLoading.collectAsState()
val items by viewModel.items.collectAsState()

derivedStateOf：避免 State 衍生导致的过度重组

// 场景：根据列表滚动位置判断是否显示"回到顶部"按钮
val listState = rememberLazyListState()

// ❌ 每次滚动都会触发 showTopButton 的重组
val showTopButton = listState.firstVisibleItemIndex > 0

// ✅ 只有 Boolean 值真正变化时才触发重组
val showTopButton by remember {
    derivedStateOf { listState.firstVisibleItemIndex > 0 }
}

六、图片加载与异步操作最佳实践

图片加载和网络请求是 Android 应用中最常见的异步操作，处理不当会严重影响 Compose 性能。

Coil 3 + AsyncImage 最佳实践

// build.gradle.kts
implementation("io.coil-kt.coil3:coil-compose:3.1.0")
implementation("io.coil-kt.coil3:coil-network-okhttp:3.1.0")

// 使用方式（自动处理内存缓存、磁盘缓存）
AsyncImage(
    model = ImageRequest.Builder(LocalContext.current)
        .data(imageUrl)
        .crossfade(true)
        .memoryCachePolicy(CachePolicy.ENABLED)
        .diskCachePolicy(CachePolicy.ENABLED)
        .build(),
    contentDescription = "User avatar",
    contentScale = ContentScale.Crop,
    modifier = Modifier.size(48.dp).clip(CircleShape)
)

LaunchedEffect vs SideEffect vs DisposableEffect

// LaunchedEffect：用于一次性或 key 变化时触发的挂起协程
LaunchedEffect(userId) {
    viewModel.loadUserData(userId) // userId 变化时重新加载
}

// SideEffect：每次重组都执行（用于同步 Compose State 到非 Compose 系统）
SideEffect {
    analyticsTracker.setCurrentScreen(currentRoute)
}

// DisposableEffect：需要清理资源时使用
DisposableEffect(lifecycleOwner) {
    val observer = LifecycleEventObserver { _, event ->
        if (event == Lifecycle.Event.ON_RESUME) viewModel.refresh()
    }
    lifecycleOwner.lifecycle.addObserver(observer)
    onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
}

七、实战 Checklist：Compose 性能优化清单

以下是一份可直接应用到项目的性能优化 Checklist：

✅ 开启编译器报告，检查关键 Composable 是否为 skippable
✅ 所有 data class 参数确保字段为 val（非 var），否则标注 @Stable/@Immutable
✅ 集合类型（List/Map/Set）使用 kotlinx.collections.immutable 或自定义 @Immutable 包装
✅ LazyList 的每个 items 都指定了稳定的 key 和 contentType
✅ 滚动位置判断统一改用 derivedStateOf 包裹
✅ Lambda 参数（onClick 等）在循环中用 remember(key) 缓存
✅ State 读取尽可能下移到最小的 Composable 范围
✅ 图片加载使用 Coil3/Glide Compose，启用内存+磁盘缓存
✅ 使用 Layout Inspector 的重组计数功能，定位热点 Composable
✅ 使用 Macrobenchmark 对关键页面做帧率基准测试

Compose 性能优化是一个需要持续迭代的过程。建议在项目初期就养成良好习惯：每新增一个 Composable，就思考它的 stability 和 recomposition 范围。结合编译器报告和 Layout Inspector，大多数性能问题在开发阶段就能被发现和修复，而不是等到上线后才发现卡顿。

AI Agent 记忆管理实战：让你的智能体真正记住上下文

Wed, 13 May 2026 08:13:32 +0800

为什么 AI Agent 需要记忆管理？

大语言模型（LLM）本质上是无状态的——每次调用都是一次全新的对话，模型对之前发生的事情一无所知。对于简单的问答场景，这并不是问题；但当我们构建需要持续工作的 AI Agent 时，缺乏记忆会导致以下问题：

无法记住用户的个人偏好和历史操作
每轮对话都要重复提供相同的背景信息
多步骤任务执行中断后无法恢复
长对话超出 Token 窗口后信息丢失

因此，记忆管理成为构建生产级 AI Agent 的必备能力。业界通常将记忆分为四个层次：短期记忆（In-Context Memory）、外部记忆（External Memory）、情景记忆（Episodic Memory）和语义记忆（Semantic Memory）。

短期记忆：对话历史的管理策略

短期记忆是最直接的方案——把对话历史直接塞入 Prompt。但 LLM 的 Context Window 有限，随着对话增长，我们需要合理的截断和压缩策略。

LangChain 提供了多种开箱即用的 Memory 组件：

from langchain.memory import (
    ConversationBufferMemory,
    ConversationSummaryMemory,
    ConversationBufferWindowMemory,
    ConversationTokenBufferMemory
)
from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 1. 滑动窗口记忆：只保留最近 K 轮对话
window_memory = ConversationBufferWindowMemory(k=5)

# 2. Token 限制记忆：按 Token 数控制记忆长度
token_memory = ConversationTokenBufferMemory(
    llm=llm,
    max_token_limit=2000
)

# 3. 摘要记忆：自动将旧对话压缩为摘要
summary_memory = ConversationSummaryMemory(llm=llm)

# 实战：使用摘要记忆构建持久对话
from langchain.chains import ConversationChain

chain = ConversationChain(llm=llm, memory=summary_memory, verbose=True)
response = chain.predict(input="我叫张伟，是一名 Python 后端工程师")
response = chain.predict(input="我最近在学习 AI Agent 开发")
response = chain.predict(input="你还记得我叫什么名字吗？")
print(response)  # 模型会正确回忆起"张伟"

对于实时性要求高的场景，推荐使用 ConversationTokenBufferMemory，它能精确控制每次 API 调用的 Token 消耗；对于长时间对话，ConversationSummaryMemory 通过动态摘要保留关键信息，是更优的选择。

长期记忆：向量数据库的引入

短期记忆无法跨会话持久化。要让 Agent 真正"记住"用户，需要引入外部存储。向量数据库是目前最主流的方案——将记忆内容嵌入为向量，通过语义相似度检索相关记忆。

以下是基于 Chroma 向量数据库实现长期记忆的完整示例：

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.memory import VectorStoreRetrieverMemory
import chromadb

# 初始化持久化向量存储
persist_dir = "./agent_memory_db"
embeddings = OpenAIEmbeddings()

vectorstore = Chroma(
    collection_name="agent_long_term_memory",
    embedding_function=embeddings,
    persist_directory=persist_dir
)

# 创建基于向量检索的记忆
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
memory = VectorStoreRetrieverMemory(retriever=retriever)

# 存储记忆片段
memory.save_context(
    {"input": "我最喜欢的编程语言是 Python"},
    {"output": "已记录您偏好 Python"}
)
memory.save_context(
    {"input": "我在北京工作，每天坐地铁上班"},
    {"output": "已记录您在北京工作"}
)
memory.save_context(
    {"input": "我有一只叫做「代码」的橘猫"},
    {"output": "已记录您的宠物信息"}
)

# 语义检索：查找与"宠物"相关的记忆
result = memory.load_memory_variables({"prompt": "告诉我关于你的猫"})
print(result["history"])
# 输出：Human: 我有一只叫做「代码」的橘猫
#        AI: 已记录您的宠物信息

# 持久化到磁盘
vectorstore.persist()
print("记忆已持久化，下次启动可直接加载")

向量记忆的核心优势在于语义检索——即使用户问的方式不同，系统也能找到最相关的历史记忆。这比简单的关键词匹配强大得多。

结构化记忆：用 JSON 存储用户画像

除了非结构化的对话记忆，很多场景需要维护结构化的用户状态，例如用户偏好、任务进度、个人档案等。推荐使用 JSON 文件或 Redis 存储，配合 Agent 的工具调用能力进行读写。

import json
import os
from datetime import datetime
from langchain.tools import tool
from langchain.agents import initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI

USER_PROFILE_PATH = "./user_profiles/{user_id}.json"

def load_profile(user_id: str) -> dict:
    path = USER_PROFILE_PATH.format(user_id=user_id)
    if os.path.exists(path):
        with open(path) as f:
            return json.load(f)
    return {"user_id": user_id, "preferences": {}, "history": []}

def save_profile(user_id: str, profile: dict):
    path = USER_PROFILE_PATH.format(user_id=user_id)
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "w") as f:
        json.dump(profile, f, ensure_ascii=False, indent=2)

@tool
def remember_user_preference(user_id: str, key: str, value: str) -> str:
    """记住用户的某个偏好或信息"""
    profile = load_profile(user_id)
    profile["preferences"][key] = value
    profile["history"].append({
        "timestamp": datetime.now().isoformat(),
        "action": f"记录偏好: {key}={value}"
    })
    save_profile(user_id, profile)
    return f"已记住：{key} = {value}"

@tool
def recall_user_info(user_id: str, query: str) -> str:
    """回忆用户的某个信息"""
    profile = load_profile(user_id)
    prefs = profile.get("preferences", {})
    if query in prefs:
        return f"{query}: {prefs[query]}"
    # 模糊匹配
    matches = {k: v for k, v in prefs.items() if query.lower() in k.lower()}
    return json.dumps(matches, ensure_ascii=False) if matches else "未找到相关记忆"

# 将工具绑定到 Agent
llm = ChatOpenAI(model="gpt-4o", temperature=0)
agent = initialize_agent(
    tools=[remember_user_preference, recall_user_info],
    llm=llm,
    agent=AgentType.OPENAI_FUNCTIONS,
    verbose=True
)

记忆管理最佳实践与踩坑总结

经过实际项目的验证，以下是构建 AI Agent 记忆系统时的关键经验：

分层存储：短期对话历史用 Token Buffer，中期用摘要压缩，长期用向量数据库——三层结合效果最佳
记忆隔离：不同用户的记忆必须严格隔离，以 user_id 作为命名空间，避免信息泄露
遗忘机制：实现 TTL（Time-To-Live）清理过期记忆，防止向量库无限膨胀
检索调优：向量检索的 top-k 值不宜过大（推荐 3-5），过多的记忆反而会引入噪声，降低回答质量
记忆蒸馏：定期用 LLM 对原始记忆进行摘要提炼，提取关键事实存入结构化存储，提升检索效率
冷启动问题：新用户没有记忆时，提供通用的 persona prompt 作为默认上下文

随着 LangGraph、AutoGen 等多 Agent 框架的成熟，记忆管理正在向更复杂的方向演进——多 Agent 共享记忆池、跨模态记忆（图文混合）、主动记忆整合等都是值得关注的前沿方向。

建议将记忆管理能力封装为独立的微服务，通过 REST API 向多个 Agent 提供统一的记忆读写接口，这样既便于维护，又能在不同 Agent 之间共享用户上下文。

Jetpack Compose 性能优化实战：告别卡顿的8个核心技巧

Tue, 12 May 2026 08:11:24 +0800

一、为什么 Jetpack Compose 性能优化如此重要

Jetpack Compose 自 2021 年正式发布以来，已经成为 Android UI 开发的官方推荐方案。与传统 View 系统相比，Compose 的声明式编程模型让 UI 代码更简洁、更易维护。然而，声明式 UI 框架有一个天然挑战：不当的写法会导致大量不必要的重组（Recomposition），严重影响应用流畅度。

在实际项目中，开发者常常遇到以下问题：

列表滑动时掉帧，FPS 低于 60
状态更新触发了整个页面的重组
动画卡顿，交互响应迟钝
内存占用随使用时间持续增长

本文将系统介绍 Jetpack Compose 性能优化的核心方法，结合实际代码示例，帮助你打造丝滑流畅的 Android 应用。

二、深入理解重组机制

理解 Compose 的重组机制是性能优化的基础。Compose 运行时会追踪每个 Composable 函数所读取的 State，当 State 发生变化时，只重组读取了该 State 的函数。但如果使用不当，依然会导致不必要的重组。

重组的基本规则：

Composable 函数的参数类型必须是稳定（Stable）类型，才能被 Compose 编译器优化跳过
不稳定的类型（如普通 class、List、Map）每次都会触发重组
Lambda 函数如果在组合外部定义，可能导致引用不稳定

使用 @Stable 和 @Immutable 注解可以帮助编译器识别稳定类型：

// 不稳定的数据类（普通 data class）
data class User(val name: String, val age: Int)

// 标记为稳定，告知 Compose 编译器参数不会意外变化
@Stable
data class User(val name: String, val age: Int)

// 完全不可变的数据类，重组跳过条件最宽松
@Immutable
data class UserProfile(val id: Long, val name: String, val avatarUrl: String)

三、remember 与 derivedStateOf 的正确使用

remember 是 Compose 中缓存计算结果的核心 API，但错误使用会带来性能问题。derivedStateOf 则用于从其他 State 派生出新的 State，避免不必要的重组。

remember 的常见误区：

// ❌ 错误：每次重组都创建新对象
@Composable
fun BadExample(items: List<String>) {
    val filteredItems = items.filter { it.isNotEmpty() } // 每次重组都重新计算
    LazyColumn {
        items(filteredItems) { item ->
            Text(item)
        }
    }
}

// ✅ 正确：用 remember 缓存计算结果
@Composable
fun GoodExample(items: List<String>) {
    val filteredItems = remember(items) {
        items.filter { it.isNotEmpty() }
    }
    LazyColumn {
        items(filteredItems) { item ->
            Text(item)
        }
    }
}

derivedStateOf 的使用场景：

// 场景：列表滚动时，只在第一项不可见时才显示"回到顶部"按钮
@Composable
fun ScrollableList() {
    val listState = rememberLazyListState()
    
    // ✅ 使用 derivedStateOf，避免每次滚动都触发重组
    val showScrollToTop by remember {
        derivedStateOf { listState.firstVisibleItemIndex > 0 }
    }
    
    Box {
        LazyColumn(state = listState) {
            items(100) { index ->
                ListItem(index)
            }
        }
        if (showScrollToTop) {
            FloatingActionButton(
                onClick = { /* scroll to top */ },
                modifier = Modifier.align(Alignment.BottomEnd)
            ) {
                Icon(Icons.Default.KeyboardArrowUp, contentDescription = "回到顶部")
            }
        }
    }
}

四、LazyList 性能调优实战

LazyColumn 和 LazyRow 是 Compose 中最常用的列表组件，也是性能问题的高发区。以下是关键优化技巧：

1. 提供稳定的 key

// ❌ 没有 key，Compose 无法识别 item 是否变化，全量重组
LazyColumn {
    items(users) { user ->
        UserCard(user)
    }
}

// ✅ 提供稳定 key，只重组真正变化的 item
LazyColumn {
    items(users, key = { user -> user.id }) { user ->
        UserCard(user)
    }
}

2. 使用 contentType 优化不同类型 item 的复用

sealed class FeedItem {
    data class Post(val content: String) : FeedItem()
    data class Ad(val imageUrl: String) : FeedItem()
}

LazyColumn {
    items(
        feedItems,
        key = { it.hashCode() },
        contentType = { item ->
            when (item) {
                is FeedItem.Post -> "post"
                is FeedItem.Ad -> "ad"
            }
        }
    ) { item ->
        when (item) {
            is FeedItem.Post -> PostCard(item)
            is FeedItem.Ad -> AdCard(item)
        }
    }
}

3. 避免在 item lambda 中进行复杂计算

// ❌ 在 item lambda 中进行重度计算
LazyColumn {
    items(articles) { article ->
        val processedContent = article.body
            .replace(Regex("\\s+"), " ")
            .take(200) // 每次重组都执行
        ArticlePreview(processedContent)
    }
}

// ✅ 数据预处理移到 ViewModel 或 remember
val processedArticles = remember(articles) {
    articles.map { article ->
        article.copy(body = article.body.replace(Regex("\\s+"), " ").take(200))
    }
}
LazyColumn {
    items(processedArticles, key = { it.id }) { article ->
        ArticlePreview(article.body)
    }
}

五、状态管理最佳实践

状态管理是 Compose 性能优化中最核心的话题。状态提升（State Hoisting）的位置直接影响重组范围。

状态下沉原则：状态应该尽量放在离使用它的 Composable 最近的位置

// ❌ 状态提升过高，导致父组件不必要的重组
@Composable
fun ParentScreen() {
    var isExpanded by remember { mutableStateOf(false) }
    var selectedTab by remember { mutableStateOf(0) }
    
    Column {
        HeavyComponent() // isExpanded 变化时，这个组件也被重组
        ExpandableCard(isExpanded, onToggle = { isExpanded = !isExpanded })
        TabRow(selectedTab, onTabSelected = { selectedTab = it })
    }
}

// ✅ 将状态下沉到需要的组件内部
@Composable
fun ExpandableCard() {
    var isExpanded by remember { mutableStateOf(false) } // 状态内聚
    // ...
}

使用 ViewModel 管理复杂状态，避免重复创建：

// ViewModel 状态定义（推荐使用 StateFlow）
class ArticleViewModel : ViewModel() {
    private val _uiState = MutableStateFlow(ArticleUiState())
    val uiState: StateFlow<ArticleUiState> = _uiState.asStateFlow()
    
    fun loadArticles() {
        viewModelScope.launch {
            repository.getArticles().collect { articles ->
                _uiState.update { it.copy(articles = articles, isLoading = false) }
            }
        }
    }
}

// Composable 中收集状态
@Composable
fun ArticleScreen(viewModel: ArticleViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    
    when {
        uiState.isLoading -> LoadingIndicator()
        uiState.articles.isEmpty() -> EmptyState()
        else -> ArticleList(uiState.articles)
    }
}

六、使用 Compose 编译器指标分析性能瓶颈

Compose 编译器可以生成详细的指标报告，帮助我们找到不稳定的 Composable 和参数类型。

在 build.gradle 中开启编译器指标：

// app/build.gradle.kts
android {
    kotlinOptions {
        freeCompilerArgs += listOf(
            "-P",
            "plugin:androidx.compose.compiler.plugins.kotlin:reportsDestination=${project.buildDir.absolutePath}/compose_metrics",
            "-P",
            "plugin:androidx.compose.compiler.plugins.kotlin:metricsDestination=${project.buildDir.absolutePath}/compose_metrics"
        )
    }
}

构建后，在 build/compose_metrics/ 目录下会生成以下报告：

*-composables.txt：每个 Composable 的重组信息
*-classes.txt：类的稳定性分析
*-composables.csv：可导入 Excel 分析的 CSV 格式报告

读取报告示例：

// composables.txt 中的典型输出
restartable skippable scheme("[androidx.compose.ui.UiComposable]") fun UserCard(
  stable user: User  // ✅ 参数稳定，可跳过
)

restartable scheme("[androidx.compose.ui.UiComposable]") fun FeedItem(
  unstable item: FeedData  // ❌ 参数不稳定，无法跳过重组
)

对于标记为 unstable 的类型，解决方案是：

添加 @Immutable 或 @Stable 注解
将 List 替换为 ImmutableList（来自 kotlinx.collections.immutable 库）
将数据类改为只包含稳定类型的属性

七、实战：使用 Layout Inspector 定位重组热点

Android Studio 的 Layout Inspector 提供了实时的重组计数功能，是定位性能问题最直观的工具。

使用步骤：

连接真机或模拟器，运行 Debug 包
打开 View → Tool Windows → Layout Inspector
勾选 Show Recomposition Counts
操作应用，观察各 Composable 旁边的重组计数
重组次数异常高的组件就是优化目标

常见的重组热点及修复方案：

// 问题：在父组件传递 onClick lambda 导致子组件重组
@Composable
fun ParentList(viewModel: MyViewModel) {
    val items by viewModel.items.collectAsState()
    
    // ❌ 每次 ParentList 重组，lambda 引用变化，子组件全部重组
    LazyColumn {
        items(items) { item ->
            ItemCard(
                item = item,
                onClick = { viewModel.onItemClick(item.id) } // 新 lambda 引用
            )
        }
    }
}

// ✅ 使用 rememberUpdatedState 或将回调移入 ViewModel
@Composable
fun ParentList(viewModel: MyViewModel) {
    val items by viewModel.items.collectAsState()
    val onItemClick = remember { { id: Long -> viewModel.onItemClick(id) } }
    
    LazyColumn {
        items(items, key = { it.id }) { item ->
            ItemCard(
                item = item,
                onClick = { onItemClick(item.id) }
            )
        }
    }
}

八、总结与性能优化检查清单

经过以上各章节的深入讲解，我们可以总结出 Jetpack Compose 性能优化的核心要点：

✅ 为数据类添加 @Stable/@Immutable 注解，确保参数稳定性
✅ 正确使用 remember(key) 缓存计算结果，避免重复计算
✅ 用 derivedStateOf 替代频繁读取的派生状态
✅ LazyList 必须提供稳定的 key，不同类型 item 提供 contentType
✅ 状态尽量内聚，避免不必要的状态提升导致大范围重组
✅ 开启编译器指标，定期检查不稳定的 Composable
✅ 使用 Layout Inspector 的重组计数功能定位热点
✅ 用 ImmutableList 替代普通 List 作为 Composable 参数

性能优化是一个持续的过程，建议在每个迭代周期中都进行性能基准测试，及时发现和修复重组问题。掌握这些技巧，你将能够构建出真正流畅的 Compose 应用，为用户带来卓越的体验。

Vibe Coding 实战指南：用 AI 辅助编程实现 10 倍开发效率

Mon, 11 May 2026 08:08:19 +0800

什么是 Vibe Coding？

2025 年初，OpenAI 创始人 Andrej Karpathy 提出了 Vibe Coding 这一概念，迅速在开发者社区引发热烈讨论。其核心思想是：开发者不再逐行编写代码，而是用自然语言描述想要实现的功能，由 AI 负责生成、调试、重构代码，开发者只需审查和验收结果。

这一范式的转变意义深远。传统开发中，程序员需要同时关注业务逻辑与实现细节；而在 Vibe Coding 中，AI 承担了大量的"体力劳动"，开发者的注意力可以完全集中在「我想要什么」而非「如何实现」。

意图驱动：用自然语言表达需求，AI 自动转化为可执行代码
快速迭代：几秒内生成初稿，几分钟内完成功能闭环
降低门槛：非专业开发者也能构建可用的软件原型
专注创造：将重复性、样板式代码的编写全部交给 AI

主流 Vibe Coding 工具横评

目前市场上已涌现出多款成熟的 Vibe Coding 工具，各有侧重：

Cursor：基于 VS Code 的 AI 编辑器，支持多文件上下文感知，Composer 模式可一键重构整个项目。适合有一定代码基础的开发者。
Windsurf（Codeium）：主打"Flow"模式，AI 能自主规划任务、创建文件、运行命令，端到端完成功能开发。
GitHub Copilot Workspace：从 Issue 到 PR 的全流程自动化，深度集成 GitHub 生态，适合团队协作场景。
Bolt.new / Lovable：面向前端和全栈应用的 Web 端 AI 编程平台，零配置即可生成并部署完整 Web 应用。
Claude Code / Gemini CLI：终端原生 AI 编程助手，适合喜欢命令行工作流的开发者。

Vibe Coding 实战技巧

工具只是手段，真正决定 Vibe Coding 效果的是你与 AI 的"沟通质量"。以下是经过大量实践总结的核心技巧：

1. 写好 Prompt 是第一生产力

模糊的需求会产生模糊的代码。好的 Prompt 应包含：目标功能、技术栈、约束条件、预期输出格式。

# ❌ 差的 Prompt
帮我做一个登录页面

# ✅ 好的 Prompt
用 React + TypeScript + Tailwind CSS 实现一个登录页面：
- 包含邮箱和密码输入框，带表单校验
- 登录按钮点击后调用 POST /api/auth/login 接口
- 登录成功跳转到 /dashboard，失败显示错误提示
- 界面风格参考 Linear，暗色主题

2. 分治原则：大任务拆小步

不要试图一次性生成整个应用。将大功能拆分为独立模块，逐步迭代，每次只让 AI 专注一个明确的子任务，成功率和质量都会大幅提升。

# 推荐的任务拆分方式
Step 1: 生成数据库 Schema 和 Model 层
Step 2: 生成 API 路由和 Controller
Step 3: 生成前端组件
Step 4: 生成单元测试
Step 5: 整合联调

3. 善用上下文文件（Rules / AGENTS.md）

大多数 AI 编辑器支持项目级规则文件（如 Cursor 的 .cursorrules，Windsurf 的 .windsurfrules）。在其中定义：技术栈偏好、代码规范、禁止模式、项目架构说明，能让 AI 在整个项目中保持一致的编码风格。

Vibe Coding 的边界与风险

Vibe Coding 并不是万能的，清醒认识其局限性同样重要：

安全隐患：AI 生成的代码可能包含 SQL 注入、XSS、不安全的依赖等漏洞，务必进行安全审查
技术债务：快速生成的代码往往缺乏一致的架构，长期积累会造成维护困难
幻觉问题：AI 可能生成看似正确实则有 bug 的代码，核心逻辑必须人工审查
过度依赖：完全依赖 AI 会导致开发者丧失基础编程能力，不利于职业发展

最佳实践是把 Vibe Coding 定位为加速器而非替代品——它处理重复劳动，你负责架构决策、业务逻辑设计和质量把关。

展望：AI 原生开发工作流

Vibe Coding 只是开始。随着多模态 AI 和 Agent 技术的成熟，软件开发工作流正在发生根本性重构：

需求文档 → 代码的自动化将越来越完整
AI Agent 将能够独立完成端到端的功能开发和部署
人类开发者的角色将向"AI 产品经理 + 架构师"演进
软件开发的门槛将持续降低，创造力将成为核心竞争力

现在正是拥抱 Vibe Coding 的最佳时机。选一个趁手的工具，从你下一个功能开始实践，亲身感受 AI 时代的开发效率革命。

PHP 8.4 新特性全解析：属性钩子、非对称可见性与懒加载实战

Sun, 10 May 2026 08:14:55 +0800

一、PHP 8.4 概览：为什么值得关注

PHP 8.4 于 2024 年 11 月 21 日正式发布，这是 PHP 8.x 系列的最新里程碑版本。相较于 8.3，此次更新不仅修复了大量 Bug，更带来了多项影响深远的语言特性改进，进一步拉近了 PHP 与现代编程语言的距离。

对于日常业务开发者而言，PHP 8.4 带来的变化涉及类属性、可见性控制、数组操作、懒加载对象等多个维度，每一项都有实际的工程价值。本文将逐一拆解，配合代码示例，让你快速上手。

属性钩子（Property Hooks）—— 告别繁琐的 getter/setter
非对称可见性（Asymmetric Visibility）—— 精细控制读写权限
链式 new 表达式不再需要括号包裹
新增数组查找函数 array_find / array_find_key
懒加载对象（Lazy Objects）原生支持

二、属性钩子（Property Hooks）深度解析

属性钩子是 PHP 8.4 最受瞩目的特性之一，它允许在属性的 get 和 set 操作上附加自定义逻辑，无需再为每个属性手写 getXxx() 和 setXxx() 方法。

<?php

class User {
    public string $name {
        get => strtoupper($this->name);
        set(string $value) {
            if (strlen($value) < 2) {
                throw new \ValueError('Name must be at least 2 characters.');
            }
            $this->name = $value;
        }
    }

    public function __construct(string $name) {
        $this->name = $name;
    }
}

$user = new User('alice');
echo $user->name; // 输出: ALICE

$user->name = 'a'; // 抛出 ValueError

通过属性钩子，我们可以在保持属性访问语法简洁的同时，内嵌验证和转换逻辑。这对于领域驱动设计（DDD）中的值对象尤为适用。

钩子支持以下几种组合：

只定义 get：属性变为只读计算属性
只定义 set：写入时触发验证/转换，读取按默认行为
同时定义 get 和 set：完整拦截读写

三、非对称可见性（Asymmetric Visibility）

PHP 8.4 引入了非对称可见性语法，允许你对同一个属性分别指定读取可见性和写入可见性：

<?php

class Order {
    public private(set) int $id;
    public protected(set) string $status = 'pending';

    public function __construct(int $id) {
        $this->id = $id;
    }

    public function confirm(): void {
        $this->status = 'confirmed';
    }
}

$order = new Order(1001);
echo $order->id;     // 公开可读
echo $order->status; // 公开可读

$order->id = 9999;   // Fatal Error：外部无法写入

这一特性让不可变值对象的构建变得更加自然，不再需要用 readonly 限制整个生命周期，而是精确地控制谁能修改属性。

常见用途：

public private(set)：外部只读，类内可写
public protected(set)：外部只读，子类可写
与属性钩子组合使用，构建健壮的值对象

四、新数组函数：array_find / array_find_key / array_any / array_all

PHP 8.4 新增了四个语义清晰的数组操作函数，填补了长期以来需要用 array_filter + reset 组合绕路的空白：

<?php

$products = [
    ['name' => 'iPhone', 'price' => 6999],
    ['name' => 'Pixel',  'price' => 4999],
    ['name' => 'Galaxy', 'price' => 5999],
];

// 找到第一个价格超过 5000 的商品
$found = array_find($products, fn($p) => $p['price'] > 5000);
var_dump($found); // ['name' => 'iPhone', 'price' => 6999]

// 找到对应的键
$key = array_find_key($products, fn($p) => $p['price'] > 5000);
var_dump($key); // int(0)

// 是否存在任一满足条件的元素
$anyExpensive = array_any($products, fn($p) => $p['price'] > 6000);
var_dump($anyExpensive); // bool(true)

// 是否所有元素都满足条件
$allExpensive = array_all($products, fn($p) => $p['price'] > 3000);
var_dump($allExpensive); // bool(true)

这四个函数让数组查询代码更加语义化、可读性更强，在日常 CRUD 业务逻辑中会频繁用到。

五、懒加载对象（Lazy Objects）与升级建议

PHP 8.4 在反射 API 中原生支持懒加载对象（Lazy Objects），这是一项对框架开发者极为重要的底层能力。懒加载对象在被真正访问之前不会执行初始化逻辑，非常适合用于依赖注入容器中的代理对象实现。

<?php

class HeavyService {
    public function __construct() {
        // 模拟耗时初始化（如数据库连接）
        sleep(1);
        echo "HeavyService initialized\n";
    }

    public function doWork(): string {
        return "Working!";
    }
}

$reflector = new ReflectionClass(HeavyService::class);

// 创建懒加载实例（此时不执行构造函数）
$lazy = $reflector->newLazyGhost(function (HeavyService $obj) {
    $obj->__construct();
});

echo "Lazy object created (no init yet)\n";

// 真正访问时才初始化
echo $lazy->doWork(); // 输出: HeavyService initialized\nWorking!

升级到 PHP 8.4 的建议：

使用 php -v 或 Docker 镜像 php:8.4-fpm 快速体验新特性
运行 composer require --dev phpstan/phpstan 借助静态分析确保兼容性
注意 PHP 8.4 废弃了 implicitly nullable 参数语法，需将 function foo(string $a = null) 改为 function foo(?string $a = null)
参考官方迁移指南：php.net/manual/en/migration84.php

PHP 8.4 在语言表达力和工程实践上都迈出了重要一步。无论是构建新项目还是维护遗留系统，了解这些新特性都将使你的 PHP 代码更简洁、更健壮。

PHP 8.4 新特性全解析：属性钩子、非对称可见性与懒对象实战指南

Sat, 09 May 2026 08:06:22 +0800

一、PHP 8.4 概览：为什么这次升级值得关注

PHP 8.4 于 2024 年 11 月正式发布，这是 PHP 8.x 系列中迄今为止改动最大、最具前瞻性的一次版本。它不仅延续了 PHP 8.0 以来的性能优化路线，更在语言层面引入了多项开发者期待已久的特性，让 PHP 在与 Python、Kotlin 等现代语言的竞争中更具吸引力。

本文将从实际开发场景出发，逐一讲解 PHP 8.4 的核心新特性，每个特性都配有可运行的代码示例，帮助你快速上手并应用到真实项目中。

属性钩子（Property Hooks）：OOP 的重大变革
非对称可见性（Asymmetric Visibility）：更精细的访问控制
全新数组函数：array_find、array_find_key 等
懒对象（Lazy Objects）：性能优化利器
HTML5 解析器：告别 libxml 的烦恼
其他改进：PDO、BCMath、JIT 增强

二、属性钩子（Property Hooks）：颠覆传统 Getter/Setter

这是 PHP 8.4 最受瞩目的特性之一。过去我们需要为每个属性手写 getXxx() 和 setXxx() 方法，代码冗余且维护成本高。属性钩子让属性本身拥有 get 和 set 逻辑，代码更简洁优雅。

<?php

class User {
    public string $firstName;
    public string $lastName;

    // 虚拟属性：fullName 由 get 钩子动态计算
    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
        set {
            [$this->firstName, $this->lastName] = explode(' ', $value, 2);
        }
    }

    // 带验证的 set 钩子
    public int $age {
        set(int $value) {
            if ($value < 0 || $value > 150) {
                throw new \ValueError("Invalid age: $value");
            }
            $this->age = $value;
        }
    }
}

$user = new User();
$user->fullName = 'Zhang Wei';
echo $user->firstName; // Zhang
echo $user->fullName;  // Zhang Wei

$user->age = 25;       // OK
$user->age = -1;       // throws ValueError

属性钩子也支持在接口中声明，实现类必须提供对应的钩子实现：

<?php

interface HasFullName {
    public string $fullName { get; }
}

class Employee implements HasFullName {
    public function __construct(
        public string $firstName,
        public string $lastName,
    ) {}

    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
    }
}

相比传统方式，属性钩子减少了大量样板代码，且与 IDE 的自动补全、静态分析工具完美兼容。

三、非对称可见性（Asymmetric Visibility）：读写权限分离

PHP 8.4 引入了非对称可见性语法，允许属性的读取和写入使用不同的访问级别。这一特性在构建领域对象（Domain Object）和值对象（Value Object）时极为实用。

<?php

class Order {
    // public 读取，private 写入
    public private(set) string $status = 'pending';

    // public 读取，protected 写入
    public protected(set) float $totalAmount = 0.0;

    public function confirm(): void {
        $this->status = 'confirmed'; // 内部可以修改
        $this->totalAmount = $this->calculateTotal();
    }

    private function calculateTotal(): float {
        // ... 计算逻辑
        return 299.99;
    }
}

$order = new Order();
echo $order->status;       // OK: "pending"
$order->status = 'paid';   // Error! 外部无法直接修改
$order->confirm();
echo $order->status;       // OK: "confirmed"

非对称可见性与只读属性（readonly）的区别在于：readonly 只能初始化一次，而非对称可见性允许类内部多次修改，外部只读。这在构建状态机、聚合根等场景下非常有用。

<?php

// 结合构造器提升（Constructor Promotion）使用
class Product {
    public function __construct(
        public readonly int $id,
        public private(set) string $name,
        public private(set) float $price,
        public private(set) int $stock = 0,
    ) {}

    public function restock(int $quantity): void {
        $this->stock += $quantity;
    }

    public function rename(string $name): void {
        $this->name = $name;
    }
}

四、全新数组函数：array_find、array_find_key、array_any、array_all

PHP 8.4 新增了 4 个实用的数组函数，填补了长期以来需要手写循环或使用 array_filter 变通方案的空缺：

<?php

$users = [
    ['id' => 1, 'name' => 'Alice', 'age' => 28, 'active' => true],
    ['id' => 2, 'name' => 'Bob',   'age' => 17, 'active' => false],
    ['id' => 3, 'name' => 'Carol', 'age' => 32, 'active' => true],
];

// array_find：返回第一个匹配的元素
$firstActive = array_find($users, fn($u) => $u['active']);
// ['id' => 1, 'name' => 'Alice', ...]

// array_find_key：返回第一个匹配元素的键
$minorKey = array_find_key($users, fn($u) => $u['age'] < 18);
// 1 (Bob 的索引)

// array_any：至少有一个元素满足条件
$hasMinor = array_any($users, fn($u) => $u['age'] < 18);
// true

// array_all：所有元素都满足条件
$allActive = array_all($users, fn($u) => $u['active']);
// false

这些函数在处理集合数据时非常高效，且比 array_filter + reset 的组合更语义化、可读性更强。在 Laravel、Symfony 等框架的 Service 层中，这些新函数将大幅简化代码。

<?php

// 实战：在商品列表中查找第一个有库存且价格在预算内的商品
$products = getProductList();
$budget = 500.0;

$suitable = array_find(
    $products,
    fn($p) => $p->stock > 0 && $p->price <= $budget
);

if ($suitable) {
    echo "推荐商品：{$suitable->name}，售价：{$suitable->price}";
} else {
    echo "暂无符合条件的商品";
}

五、懒对象（Lazy Objects）：按需实例化，提升性能

PHP 8.4 在 ReflectionClass 中内置了懒对象支持，无需第三方库即可实现延迟实例化。这一特性对 DI 容器、ORM 延迟加载、代理对象场景极为重要。

<?php

class DatabaseConnection {
    public function __construct(
        private string $dsn,
        private string $username,
        private string $password,
    ) {
        echo "Connecting to database...\n"; // 真正连接时才执行
        // new PDO($this->dsn, $this->username, $this->password);
    }

    public function query(string $sql): array {
        // ...
        return [];
    }
}

// 创建懒对象——此时不会调用构造器
$reflector = new ReflectionClass(DatabaseConnection::class);
$db = $reflector->newLazyGhost(function (DatabaseConnection $instance) {
    // 初始化回调：第一次访问属性时触发
    $instance->__construct(
        dsn: 'mysql:host=localhost;dbname=myapp',
        username: 'root',
        password: 'secret'
    );
});

echo "Lazy object created.\n"; // 不会打印 "Connecting..."

// 直到第一次真正使用时，才会初始化
$result = $db->query('SELECT * FROM users'); // 现在才连接数据库

懒对象分为两种类型：

Lazy Ghost：对同一个对象实例进行延迟初始化，初始化后对象身份不变
Lazy Proxy：使用代理包装真实对象，适合不能直接控制构造器的场景

<?php

// Lazy Proxy 示例
$reflector = new ReflectionClass(DatabaseConnection::class);
$proxy = $reflector->newLazyProxy(function (DatabaseConnection $proxy) {
    return new DatabaseConnection('mysql:host=prod-server', 'app', 'prod_secret');
});

// 代理对象与真实对象是不同实例
// 适用于需要替换底层实例的场景（如切换数据库连接）

六、HTML5 解析器：全新的 DOM 扩展

PHP 长期依赖基于 libxml 的 HTML 解析器，对 HTML5 的支持存在诸多缺陷。PHP 8.4 引入了基于 Lexbor 引擎的全新 HTML5 解析器，通过新的 Dom\HTMLDocument 和 Dom\XMLDocument 类提供支持。

<?php

// 旧方式（libxml，对 HTML5 支持不完整）
$oldDoc = new DOMDocument();
@$oldDoc->loadHTML($html); // 需要 @ 抑制错误

// 新方式（PHP 8.4，基于 Lexbor，完整支持 HTML5）
$doc = Dom\HTMLDocument::createFromString($html, LIBXML_NOERROR);

// 支持现代 CSS 选择器（querySelector）
$title = $doc->querySelector('h1.title');
$items = $doc->querySelectorAll('.nav-item');

foreach ($items as $item) {
    echo $item->textContent . "\n";
}

// 从 URL 加载（内部使用 file_get_contents）
// $doc = Dom\HTMLDocument::createFromFile('https://example.com');

// 序列化输出
echo $doc->saveHTML();

新解析器的优势：

完整支持 HTML5 标准，不再需要 @ 压制错误
支持 querySelector / querySelectorAll CSS 选择器
支持命名空间感知的节点操作
与浏览器行为一致，爬虫和内容处理场景更可靠

七、其他重要改进与升级建议

除了上述主要特性，PHP 8.4 还包含以下值得关注的改进：

PDO 驱动子类

PHP 8.4 引入了 Pdo\Mysql、Pdo\Sqlite、Pdo\Pgsql 等 PDO 驱动子类，每个子类包含特定数据库的专有方法，类型系统更完善：

<?php

// 现在可以使用类型声明指定具体的 PDO 子类
function mysqlQuery(Pdo\Mysql $pdo, string $sql): array {
    return $pdo->query($sql)->fetchAll();
}

$pdo = new Pdo\Mysql('mysql:host=localhost;dbname=test', 'root', '');
$rows = mysqlQuery($pdo, 'SELECT * FROM users');

BCMath 对象 API

BCMath 扩展新增了 BcMath\Number 类，支持运算符重载，告别繁琐的函数调用：

<?php

use BcMath\Number;

$price = new Number('19.99');
$qty   = new Number('3');
$tax   = new Number('0.08');

// 直接用运算符，无需 bcmul/bcadd
$subtotal = $price * $qty;          // 59.97
$taxAmount = $subtotal * $tax;      // 4.7976
$total = $subtotal + $taxAmount;    // 64.7676

echo $total->value;                 // "64.7676"

升级建议

使用 php-codesniffer 或 rector 工具自动检测和迁移废弃特性
PHP 8.4 废弃了隐式可空类型（function foo(string $x = null)），需改为 ?string
建议先在测试环境升级，运行完整测试套件后再上生产
Composer 依赖检查：composer why-not php 8.4
推荐配合 PHPStan level 8 + Rector PHP 8.4 规则集做静态分析

PHP 8.4 代表了 PHP 语言现代化进程中的重要里程碑。属性钩子和非对称可见性让面向对象编程更加优雅，新数组函数和懒对象提升了开发效率，HTML5 解析器解决了多年痛点。现在就开始升级，享受这些特性带来的生产力提升吧！

PHP 8.1 Fibers 实战：用协程重塑高并发异步编程

Fri, 08 May 2026 08:09:41 +0800

什么是 PHP Fibers？

PHP 8.1 引入了 Fibers（纤程），这是 PHP 并发编程领域的重大革新。Fibers 提供了一种轻量级的协作式多任务机制，让开发者可以在单线程中实现类似协程的效果，无需依赖多进程或多线程。

与传统的同步代码不同，Fibers 允许代码在执行过程中主动"暂停"自身，将控制权交还给调用方，之后再从暂停点继续执行。这种机制特别适合处理 I/O 密集型任务，如数据库查询、HTTP 请求等。

轻量级：每个 Fiber 只占用极少内存，可以创建大量并发 Fiber
可控性强：完全由开发者控制暂停和恢复的时机
无需扩展：PHP 8.1+ 内置支持，无需安装额外扩展
异常安全：支持在 Fiber 内部抛出和捕获异常

Fibers 核心 API 详解

PHP Fibers 的核心 API 非常简洁，主要围绕 Fiber 类展开：

<?php

// 创建一个 Fiber
$fiber = new Fiber(function(): string {
    $value = Fiber::suspend('第一次暂停');  // 暂停并传递值给外部
    echo "从外部收到: {$value}\n";
    
    $value2 = Fiber::suspend('第二次暂停');
    echo "再次从外部收到: {$value2}\n";
    
    return '最终返回值';
});

// 启动 Fiber，获取第一次 suspend 的值
$firstSuspendedValue = $fiber->start();
echo "Fiber 第一次暂停，传来: {$firstSuspendedValue}\n";

// 恢复 Fiber，向它传值，并获取第二次 suspend 的值
$secondSuspendedValue = $fiber->resume('hello');
echo "Fiber 第二次暂停，传来: {$secondSuspendedValue}\n";

// 再次恢复，Fiber 结束
$fiber->resume('world');

// 获取返回值
echo "Fiber 返回: " . $fiber->getReturn() . "\n";

输出结果为：

Fiber 第一次暂停，传来: 第一次暂停
从外部收到: hello
Fiber 第二次暂停，传来: 第二次暂停
再次从外部收到: world
Fiber 返回: 最终返回值

实战：构建简单的异步任务调度器

Fibers 最典型的应用场景是构建异步任务调度器。下面是一个简单但完整的示例，展示如何用 Fibers 模拟并发执行多个任务：

<?php

class SimpleScheduler
{
    private array $fibers = [];
    private array $queue = [];

    public function addTask(callable $callback): void
    {
        $this->fibers[] = new Fiber($callback);
    }

    public function run(): void
    {
        // 启动所有 Fiber
        foreach ($this->fibers as $fiber) {
            $this->queue[] = fn() => $fiber->start();
        }

        // 事件循环
        while (!empty($this->queue)) {
            $task = array_shift($this->queue);
            $fiber = $task();

            if ($fiber instanceof Fiber && !$fiber->isTerminated()) {
                // Fiber 尚未结束，重新加入队列
                $this->queue[] = fn() => $fiber->resume();
            }
        }
    }
}

$scheduler = new SimpleScheduler();

$scheduler->addTask(function() {
    echo "[任务A] 开始执行\n";
    Fiber::suspend();
    echo "[任务A] 第二阶段\n";
    Fiber::suspend();
    echo "[任务A] 完成\n";
});

$scheduler->addTask(function() {
    echo "[任务B] 开始执行\n";
    Fiber::suspend();
    echo "[任务B] 第二阶段\n";
    Fiber::suspend();
    echo "[任务B] 完成\n";
});

$scheduler->run();

这个示例展示了任务交替执行的核心思想——这也是 ReactPHP、Amp 等异步框架的底层实现原理。

Fibers 与 Promise/异步框架集成

单独使用 Fibers 的场景相对有限，它真正的威力在于与异步框架结合。以 Amp v3 为例，Fibers 是其核心基础：

<?php
// 使用 Amp v3（基于 Fibers）
use Amp\Http\Client\HttpClientBuilder;
use function Amp\async;
use function Amp\await;

$client = HttpClientBuilder::buildDefault();

// 并发发起多个 HTTP 请求
$futures = [
    async(fn() => $client->request(new Request('https://api.example.com/users'))),
    async(fn() => $client->request(new Request('https://api.example.com/posts'))),
    async(fn() => $client->request(new Request('https://api.example.com/comments'))),
];

// 等待所有请求完成
[$usersResp, $postsResp, $commentsResp] = await($futures);

echo "用户数据: " . $usersResp->getBody()->buffer() . "\n";
echo "文章数据: " . $postsResp->getBody()->buffer() . "\n";

相比传统的回调地狱或 Promise 链式调用，基于 Fibers 的代码看起来就像同步代码，但实际是并发执行的。这大幅降低了异步编程的心智负担。

性能对比与最佳实践

在实际项目中使用 Fibers 时，需要注意以下几点：

适合 I/O 密集型场景：数据库查询、Redis 操作、HTTP 请求等，并发效果显著
不适合 CPU 密集型场景：Fibers 是协作式的，CPU 计算不会主动让出控制权
避免在 Fiber 中使用阻塞函数：如 sleep()、file_get_contents() 等会阻塞整个进程
错误处理要完善：未捕获的异常会终止整个 Fiber，需要做好异常边界
配合 Swoole 或 OpenSwoole：在常驻内存的服务中，Fibers 的优势更加突出

简单性能测试数据显示，在处理 100 个并发 HTTP 请求时，使用 Fibers 的异步方案比传统同步方案快 8-15 倍，内存占用降低约 40%。

PHP Fibers 为 PHP 带来了现代化的并发编程能力。随着 Amp、ReactPHP 等框架对 Fibers 的全面支持，PHP 在高并发场景下的表现已经不逊色于 Node.js 和 Go。对于后端开发者来说，现在正是学习和实践 PHP 异步编程的最佳时机。