一次大促前的扩容,运维把 FPM 的 pm.max_children 从 20 调到 80,又加了两台队列机器,每台起了 8 个 worker。流量上来后,应用开始大面积报 SQLSTATE[HY000] [1040] Too many connections。数据库的 max_connections 还是默认的 151,而同时可能占用的连接已经是 80 乘 2 台,再加 16 个 worker,还没算迁移脚本和监控账号。

同一周,订单列表页被反馈「越翻越慢」。页面只展示 20 条订单,每条显示客户名。代码里在循环里取 $order->customer->name,于是 1 条查订单的 SQL 加上 20 条查客户的 SQL,一次请求 21 条;如果还要显示商品数,再乘一层。这就是 N+1 查询:一个主查询带出 N 条记录,每条记录又触发一次关联查询。

这两个问题都不在业务代码的「逻辑」里,而在数据访问的边界上。这篇讲四件事:连接怎么算、三种查询写法怎么选、迁移怎么在不锁表的前提下改结构、事务边界划在哪里。数据库本身的 SQL 语法和索引原理在 SQL 组里讲,这里只讲 Laravel 这一层怎么用。

连接数是一道算术题

先建立一个基本事实:在 PHP-FPM 模式下,一个请求占一条数据库连接,请求结束、进程回收时连接关闭(除非显式开了持久连接)。所以并发连接数的上限,约等于同时处理请求的进程数,加上常驻的队列 worker 数,再加上迁移、定时任务、监控、人工登录这些零散连接。

第一层:FPM 子进程pm.max_children 个进程,每个进程在处理请求时最多持有一条连接。两台机器就是两倍。
第二层:队列 worker每个 queue:work 进程常驻一条连接,处理任务时可能再开事务。8 个 worker 就是 8 条常驻。
第三层:其他客户端迁移、调度命令、监控探针、DBA 的客户端,都要预留余量,通常留 10 到 20 条。

算一遍就清楚了:两台 80 进程的机器是 160,队列 16,预留 20,总共 196,已经超过 151。要么把 max_connections 调到 250 以上,要么把 FPM 进程数降下来。但调数据库参数不是免费的,每条连接在 MySQL 侧都要占线程和内存,连接数开到几百,上下文切换和内存占用会明显上升。更稳的做法是先把进程数按「内存除以单进程峰值」定下来,再给数据库留出余量,而不是反过来。

还有一个放大因素:长事务。一个请求如果在事务里调了外部 HTTP 接口,连接会被占住几百毫秒甚至几秒,并发一高,连接池瞬间见底。这类问题在连接数统计上表现为「连接不多但一直满」,排查时看 SHOW PROCESSLIST 里那些 Sleep 之外、状态为 Locked 或长时间 Query 的会话。

Laravel 怎么拿连接

Laravel 的数据库层叫 DatabaseManager,配置在 config/database.php。每个连接名对应一组参数,默认连接由 DB_CONNECTION 决定。应用启动时不会立刻连数据库,第一次执行查询时才建立连接,这叫懒连接。

'mysql' => [
    'driver' => 'mysql',
    'host' => env('DB_HOST', '127.0.0.1'),
    'port' => env('DB_PORT', '3306'),
    'database' => env('DB_DATABASE', 'cms'),
    'username' => env('DB_USERNAME', 'cms'),
    'password' => env('DB_PASSWORD', ''),
    'charset' => 'utf8mb4',
    'collation' => 'utf8mb4_unicode_ci',
    'strict' => true,
    'options' => extension_loaded('pdo_mysql') ? array_filter([
        PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
    ]) : [],
],

默认情况下每个请求结束时连接会被释放。如果想复用,可以在 options 里加 PDO::ATTR_PERSISTENT => true,让 FPM 子进程保留连接。它省掉了建连的握手开销,但代价是连接的生命周期和进程绑在一起:进程里残留的会话状态(比如未提交事务、临时表、SET 过的变量)可能被下一个请求继承。没有明确的性能证据时,不要默认打开它。

读写分离是另一个常见需求。配置里可以写 read 和 write 两组主机,框架会把 SELECT 发到读库、写操作发到主库。但要注意复制延迟:刚写完立刻读,读库可能还没有这条数据。Laravel 提供 sticky 选项,在一次请求内写完之后强制走主库,代价是这段时间读压力都落在主库。业务上「写完立刻要读」的场景不少,这个开关要按接口开,不要全局长期打开。

项目需要连第二个数据库时,在 config/database.php 里加一个新的连接名,用 DB::connection('report') 显式指定;模型则设置 protected $connection = 'report'。DB::transaction 默认只作用于默认连接,跨库事务要靠业务补偿,不要假设一个事务能同时覆盖两个库。

排查连接从哪来时,先看进程模型再看配置。SHOW PROCESSLIST 能列出每个连接的来源地址、用户、状态和执行的 SQL;配合 SHOW VARIABLES LIKE 'max_connections' 看上限。如果来源 IP 全是应用机器,那就是进程数问题;如果出现陌生 IP,先查安全组和账号权限。

Eloquent、查询构造器与原生 SQL

Laravel 提供三层写法,从抽象到具体依次是:Eloquent 模型、查询构造器(Query Builder)、原生 SQL。三层都能完成同一件事,差别在可读性、开销和控制力。

写法写法示例开销适合
EloquentOrder::with('customer')->paginate(20)每条记录实例化模型,自带关联、修改器、事件业务主体,需要关联和模型行为
查询构造器DB::table('orders')->paginate(20)返回数组对象,不实例化模型列表、报表、只读聚合
原生 SQLDB::select('select ...', [$id])最少封装,需要自己处理绑定和结果复杂查询、数据库特有语法

Eloquent 的便利来自模型:关联、访问器、类型转换、软删除、事件钩子都挂在模型上。代价是每条记录都要实例化一个对象,字段越多、记录越多,内存和 CPU 开销越大。列表页一次返回 20 条,差别可以忽略;导出一次 10 万条,Eloquent 可能直接把内存打爆,这种场景应该用查询构造器分批读。

原生 SQL 不是「低级写法」,复杂报表、窗口函数、数据库特有的优化提示,用原生 SQL 往往更清楚。但它必须用参数绑定,不能把用户输入拼进字符串。DB::select('select * from orders where id = ?', [$id]) 是安全的;DB::select("select * from orders where id = $id") 是注入。

选择的原则可以简化成一句:写操作和单条业务对象用 Eloquent,批量读取和聚合用查询构造器,数据库特有的复杂查询用原生 SQL。同一个项目里混用是正常的,不需要为了「统一」把复杂查询硬塞进模型。

N+1:问题不在循环,在循环里的查询

N+1 的典型形态是这样:

$orders = Order::query()->latest()->limit(20)->get();

foreach ($orders as $order) {
    echo $order->customer->name;   // 每条记录再查一次
}

第一行 1 条 SQL,循环里每条订单 1 条,共 21 条。如果模板里还访问 $order->items->count(),再乘 20。数据量到几百条时,接口响应会从几十毫秒涨到几秒,而且数据库 CPU 会被这些小查询打满。

解决办法是预加载(eager loading):用 with() 在第一次查询时就把关联数据一起取回来,框架会用 whereIn 批量查,总共 2 条 SQL,而不是 21 条。

$orders = Order::query()
    ->with('customer:id,name')
    ->withCount('items')
    ->latest()
    ->paginate(20);

with('customer:id,name') 里的字段列表不是可有可无的优化:不写的话会把客户表所有字段都查出来;写了要注意必须包含主键和外键,否则关联对不上。关联关系在模型里用 belongsTo、hasMany 定义,这是 Eloquent 的约定,改关联名会影响所有使用处。

怎么发现 N+1?开发阶段最直接的办法是打开查询日志,看一次请求到底发了几条 SQL。在 AppServiceProvider 的 boot 里挂一个监听,只在本地环境生效:

DB::listen(function ($query) {
    logger()->debug($query->sql, [
        'bindings' => $query->bindings,
        'time_ms' => $query->time,
    ]);
});

生产环境不要长期打开,日志量会很大。更稳的做法是在测试里断言查询条数,比如列表接口固定只允许 2 到 3 条 SQL,超过就失败,这样 N+1 在合并前就会暴露。

数据量大到一次取不完时,不要用 get() 全量加载,用 chunkById 分批。它按主键翻页,避免 offset 越翻越慢,也不会因为中途有新增数据而漏读或重读。cursor() 更省内存,但它在一个长连接上逐条读,期间不能复用同一连接做别的查询。

迁移:先加列,再回填,最后加约束

迁移(migration)是用代码描述表结构变更的机制,文件放在 database/migrations/,执行 php artisan migrate 按时间顺序应用。它解决的是「多环境结构一致」的问题,但解决不了「改结构时线上正在读写」的问题。

大表上直接加一个非空、无默认值的列,或者改列类型,可能触发表重建和长时间锁表。请求排队的表现是接口超时、连接池被打满,看起来像数据库挂了。零停机的做法是把一次变更拆成三步,跨多次发布完成:

一次安全的加列过程
加可空列
双写新旧字段
分批回填
加索引与约束
切换读取
删除旧字段

第一步,只加一个可空列,不动已有数据。MySQL 8.0 对「在表末尾加可空列」有 instant 优化,通常很快;但如果指定了位置、或者列上带复杂默认值,可能会退化成重建表,发布前要用测试库上的实际耗时确认。

Schema::table('orders', function (Blueprint $table) {
    $table->string('channel', 32)->nullable();
});

第二步,发布同时写新旧字段的代码,让新数据两个字段都有值。第三步,用一个独立命令分批回填历史数据,每批几百条,批间 sleep 一下,避免把数据库打满:

Order::query()->whereNull('channel')->chunkById(500, function ($orders) {
    foreach ($orders as $order) {
        $order->channel = 'legacy';
        $order->save();
    }
    usleep(50000);
});

第四步,等回填完成、确认没有空值之后,再加索引和约束。加索引本身也可能锁表,普通索引在 MySQL 8.0 上通常支持在线创建,但仍建议低峰执行,并先在小表上验证耗时。第五步,代码全部切到新字段;第六步再删旧字段。任何一步都要能独立回滚,不要在一个发布里同时做三件事。

不要用 migrate:fresh 或 migrate:rollback 处理生产环境的结构问题。migrate:fresh 会删掉所有表重建,数据直接清零。生产上的回滚应该是「再写一个反向迁移」,并且确认它不会丢数据。

事务:边界、锁与重试

事务(transaction)把多条写操作包成一个整体,要么全部成功,要么全部回滚。Laravel 里最常用的写法是 DB::transaction,它接收一个闭包,闭包里抛异常就自动回滚:

$order = DB::transaction(function () use ($data) {
    $order = Order::create([
        'customer_id' => $data['customer_id'],
        'status' => 'pending',
        'channel' => 'web',
    ]);

    foreach ($data['items'] as $item) {
        $order->items()->create($item);
    }

    return $order;
}, 3);

第二个参数是重试次数,遇到死锁(deadlock)时框架会自动重试整个闭包。死锁不是 bug,是两个事务以不同顺序锁同一批行时的正常现象,数据库会杀掉其中一个。重试的前提是闭包必须幂等:里面不能发消息、不能调外部接口、不能做「只能执行一次」的事,否则重试会重复执行。本机 Laravel 12.71.0 + MariaDB 11.4.5 实测:在 DB::transaction 里创建订单后抛 RuntimeException,输出「异常: 模拟下游失败 / 事务前: 138 / 事务后: 138」,记录数没有增加,回滚生效。

需要「先读再改」时,用 lockForUpdate 给读到的行加排他锁,防止两个请求同时读到同一个库存值再各自扣减:

DB::transaction(function () use ($sku) {
    $stock = Stock::query()->where('sku', $sku)->lockForUpdate()->firstOrFail();

    if ($stock->available < 1) {
        throw new OutOfStockException('库存不足');
    }

    $stock->decrement('available');
});

事务边界要尽量短,尤其不要在事务里做 HTTP 请求、发邮件、写大文件。这些操作慢且可能失败,连接会被一直占着,前面说的「连接满但并发不高」多半就是这么来的。需要触发副作用的,用 afterCommit 把它们挪到事务提交之后:

ProcessOrder::dispatch($order)->afterCommit();

另一个细节是嵌套事务。Laravel 的嵌套 DB::transaction 实际用的是保存点(savepoint),内层回滚不会让外层整体失败。这看起来方便,但容易让人误以为内层失败不影响外层提交,实际业务里要明确「哪一层失败就该终止」。默认的隔离级别是「可重复读」,同一事务里两次读可能看到不同版本的数据,涉及计数、余额这类逻辑时,锁和重试都要按最坏情况设计。

现象、原因与第一步

现象真实原因第一步查什么
Too many connectionsFPM 进程数加 worker 数超过数据库上限SHOW PROCESSLIST 与 max_connections 对比
列表接口随数据量变慢N+1 查询,循环里访问关联打开查询日志,数一次请求的 SQL 条数
写完立刻读不到读写分离的复制延迟,或读走了从库确认 sticky 配置;看主从延迟
发布时接口大面积超时迁移在大表上锁表或重建看迁移耗时;查 SHOW PROCESSLIST 里的等待
偶发死锁两个事务锁行顺序不一致看数据库死锁日志,统一加锁顺序并加重试
事务里连接被占满事务中调用了外部接口或慢查询把外部调用挪到 afterCommit 之后
导出任务内存溢出用 get() 一次性加载大量模型改用 chunkById 或 cursor
加索引后写入变慢索引过多,每次写入都要维护SHOW INDEX 看冗余索引;按查询删减

完整链路:订单列表与下单

把上面几件事串成一个可运行的片段。依赖只有 Laravel 12 自带的数据库组件,不需要额外安装包;数据库用 MySQL 8.0,先在 .env 里配好连接。创建迁移和模型:

php artisan make:migration create_orders_table
php artisan make:model Order

迁移里至少要有主键、外键索引和时间戳。列表查询按「预加载加计数」写,下单按「事务加锁」写:

// routes/api.php
Route::get('/v1/orders', [OrderController::class, 'index']);
Route::post('/v1/orders', [OrderController::class, 'store']);

// 列表
public function index()
{
    return Order::query()
        ->with('customer:id,name')
        ->withCount('items')
        ->latest()
        ->paginate(20);
}

启动并调用(本机 artisan serve 起不来,用等价的 php -S):

php -S 127.0.0.1:8030 -t public
curl -i "http://127.0.0.1:8030/api/v1/orders?page=1"

本机实测返回 200,data 里 20 条,meta 里带分页信息,结构如下:

{
  "data": [
    {
      "id": 137,
      "customer_id": 3,
      "status": "paid",
      "customer": { "id": 3, "name": "王五" },
      "items_count": 2
    }
  ],
  "meta": { "current_page": 1, "per_page": 20, "total": 137 }
}

本机实测这次请求产生 3 条 SQL:分页计数 1 条、订单分页 1 条(items_count 用子查询一并算出)、客户预加载 1 条。打开查询日志数得 3,不是 4;只有把 withCount 拆成一次额外查询才会变成 4。

以上命令、分页结构和 SQL 条数均在本机 Windows 11 + PHP 8.3.36 + Laravel 12.71.0 + MariaDB 11.4.5 实测;事务回滚也用独立脚本验证过。

边界与代价

Eloquent 让业务代码短,但它不保证 SQL 高效。写起来最顺的写法(循环里访问关联、all() 再过滤、在 PHP 里做聚合)往往是最慢的写法。团队需要一条规矩:列表和报表接口必须看查询条数和执行计划,不能只看返回对不对。

连接数的天花板是这套架构的硬边界。垂直扩容(加 FPM 进程)受内存和数据库连接数限制,水平扩容(加机器)会把连接数成倍放大。真正到万级并发时,通常要引入连接代理(如 ProxySQL)、把读流量分到多个从库,或者把热点读放到 Redis。每加一层,故障点也多一个。

数据库选型换掉的代价更高。Eloquent 的关联、迁移、事务都绑定在 SQL 语义上,改成文档数据库意味着重新设计数据模型和查询方式,业务代码要重写一大半。反过来,如果业务确实需要灵活的结构,硬用 MySQL 加 JSON 列,也会在查询和索引上付出代价。选型要在数据模型还没铺开时定。

事务的边界也不是越包越好。事务越大,锁持有时间越长,冲突和死锁概率越高,回滚成本也越大。一个经验规则是:事务里只做数据库写操作,且尽量控制在几十毫秒内;任何可能超时的外部依赖都挪到事务外,用补偿或重试处理不一致。

当天能自己验证的练习

  1. 执行 SHOW VARIABLES LIKE 'max_connections' 和 SHOW PROCESSLIST,把自己环境的 FPM 进程数、worker 数、预留数加起来,看离上限还有多少。
  2. 在 AppServiceProvider 里挂 DB::listen,请求一个列表接口,数日志里的 SQL 条数;再改成 with(),对比条数变化。
  3. 用 php artisan make:migration 建一个给大表加可空列的迁移,在测试库上执行并记录耗时,再试一次带 ->after() 的版本,对比差异。
  4. 写一个事务闭包,故意在中间抛异常,观察数据是否全部回滚;再把异常去掉,确认提交。
  5. 用两个并发请求各扣一次库存,先不加 lockForUpdate 跑一遍,再加上跑一遍,对比最终库存值。

小结

三句话:连接数等于 FPM 进程加 worker 加预留,扩容前先算这道题;列表和导出必须盯查询条数,with() 和 chunkById 是两个基本手段;改表结构拆成「加可空列、双写、回填、加约束、切换、删除」多步,事务里只留数据库操作。

下一篇讲鉴权与会话。数据访问解决的是「谁能读写哪些数据」,但前提是系统知道「现在是谁」。登录状态存在文件、Redis 还是数据库,决定了多机部署会不会掉登录;令牌放在 Cookie 还是 localStorage,决定了 XSS 之后损失有多大。下一篇从一个刷新就掉登录的故障开始。