PHP怎么优化并发能力

wen PHP项目 2026-08-11 155

PHP并发能力优化方案

基础架构优化

使用现代PHP版本

// PHP 8+ 提供了更好的性能
- PHP 8.1+ 支持 Fibers（纤程）
- PHP 8.0+ JIT编译支持
- 使用最新稳定版本（如8.2/8.3）

使用FPM优化配置

; php-fpm.conf 关键配置
pm = dynamic
pm.max_children = 50
pm.start_servers = 10
pm.min_spare_servers = 5
pm.max_spare_servers = 20
pm.max_requests = 1000
; 超时设置
request_terminate_timeout = 30
request_slowlog_timeout = 5

缓存层优化

多级缓存架构

<?php
class CacheManager {
    private $redis;
    public function __construct() {
        $this->redis = new Redis();
        $this->redis->connect('127.0.0.1', 6379);
    }
    public function getData($key) {
        // 一级缓存：内存（当前请求）
        static $localCache = [];
        if (isset($localCache[$key])) {
            return $localCache[$key];
        }
        // 二级缓存：Redis
        $data = $this->redis->get($key);
        if ($data === false) {
            // 三级缓存：数据库
            $data = $this->getFromDB($key);
            // 设置Redis缓存，防止缓存雪崩
            $ttl = rand(300, 600);
            $this->redis->setex($key, $ttl, $data);
        } else {
            $data = json_decode($data, true);
        }
        $localCache[$key] = $data;
        return $data;
    }
    private function getFromDB($key) {
        // 模拟数据库查询
        $pdo = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
        $stmt = $pdo->prepare('SELECT * FROM cache_table WHERE key = ?');
        $stmt->execute([$key]);
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }
}

异步处理方案

消息队列实现异步

<?php
// 异步任务示例
class AsyncTask {
    private $redis;
    public function __construct() {
        $this->redis = new Redis();
        $this->redis->connect('127.0.0.1', 6379);
    }
    public function pushTask($queue, $data) {
        // 将任务推入队列
        return $this->redis->lpush($queue, json_encode([
            'data' => $data,
            'time' => time()
        ]));
    }
    public function processQueue($queue) {
        // 后台处理队列任务
        while (false !== ($task = $this->redis->brpop($queue, 10))) {
            $taskData = json_decode($task[1], true);
            // 处理业务逻辑
            $this->processTask($taskData['data']);
        }
    }
    private function processTask($data) {
        // 耗时任务处理
        sleep(2);
        // 发送邮件、生成报表等
    }
}

使用Swoole/Workerman

// Swoole协程示例
use Swoole\Coroutine;
use function Swoole\Coroutine\go;
$server = new Swoole\Http\Server("127.0.0.1", 9501);
$server->on('request', function ($request, $response) {
    go(function () use ($request, $response) {
        // 并发处理
        $tasks = [
            function() { return $this->apiCall1(); },
            function() { return $this->apiCall2(); },
            function() { return $this->apiCall3(); }
        ];
        $results = Coroutine\parallel($tasks);
        $response->end(json_encode($results));
    });
});
$server->start();

数据库优化

连接池化

<?php
class DatabasePool {
    private static $pool = [];
    private static $maxConnections = 20;
    private static $currentConnections = 0;
    public static function getConnection() {
        if (!empty(self::$pool)) {
            return array_pop(self::$pool);
        }
        if (self::$currentConnections >= self::$maxConnections) {
            // 等待空闲连接
            usleep(10000);
            return self::getConnection();
        }
        self::$currentConnections++;
        return self::createConnection();
    }
    public static function releaseConnection($conn) {
        if (count(self::$pool) < self::$maxConnections) {
            self::$pool[] = $conn;
        } else {
            self::$currentConnections--;
            $conn = null;
        }
    }
    private static function createConnection() {
        // 创建PDO连接
        return new PDO(
            'mysql:host=localhost;dbname=test;charset=utf8mb4',
            'user',
            'pass',
            [
                PDO::ATTR_PERSISTENT => true,
                PDO::ATTR_TIMEOUT => 2
            ]
        );
    }
}

并发会话处理

<?php
// Session并发处理
class SessionHandler {
    private $prefix = 'session:';
    private $ttl = 3600;
    public function read($sessionId) {
        // 使用Redis存储Session
        $data = $this->redis->get($this->prefix . $sessionId);
        return $data ?: '';
    }
    public function write($sessionId, $data) {
        return $this->redis->setex(
            $this->prefix . $sessionId,
            $this->ttl,
            $data
        );
    }
    // 防止Session并发冲突
    public function lockSession($sessionId) {
        $lockKey = $this->prefix . $sessionId . ':lock';
        $lockAcquired = $this->redis->setnx($lockKey, time());
        if ($lockAcquired) {
            $this->redis->expire($lockKey, 10);
        }
        return $lockAcquired;
    }
}

代码级并发优化

文件锁处理并发

<?php
class FileConcurrency {
    public function updateFile($file, $newContent) {
        $fp = fopen($file, 'a');
        if (flock($fp, LOCK_EX)) {  // 获取独占锁
            ftruncate($fp, 0);      // 清空文件
            fwrite($fp, $newContent);
            flock($fp, LOCK_UN);    // 释放锁
        } else {
            throw new Exception("无法获取文件锁");
        }
        fclose($fp);
    }
}

Redis分布式锁

<?php
class DistributedLock {
    private $redis;
    private $lockTimeout = 10;
    public function acquireLock($key, $requestId) {
        $result = $this->redis->set(
            $key,
            $requestId,
            ['NX', 'EX' => $this->lockTimeout]
        );
        return $result !== false;
    }
    public function releaseLock($key, $requestId) {
        // 使用Lua脚本确保原子性
        $script = "
            if redis.call('get', KEYS[1]) == ARGV[1] then
                return redis.call('del', KEYS[1])
            else
                return 0
            end
        ";
        return $this->redis->eval($script, [$key, $requestId], 1);
    }
}

资源限制与动态调整

; 根据服务器配置动态调整
memory_limit = 256M
max_execution_time = 30
max_input_time = 60
upload_max_filesize = 20M
; OpCache设置
[opcache]
opcache.enable = 1
opcache.memory_consumption = 128
opcache.interned_strings_buffer = 8
opcache.max_accelerated_files = 10000
opcache.validate_timestamps = 0
opcache.save_comments = 0
opcache.fast_shutdown = 1

监控与调优

<?php
// 性能监控
class PerformanceMonitor {
    public function trackRequest() {
        $start = microtime(true);
        $memory = memory_get_usage();
        return function ($status = 'success') use ($start, $memory) {
            $end = microtime(true);
            $duration = $end - $start;
            $memoryUsage = memory_get_usage() - $memory;
            $this->logMetrics([
                'duration' => $duration,
                'memory' => $memoryUsage,
                'status' => $status,
                'time' => date('Y-m-d H:i:s')
            ]);
        };
    }
}

负载均衡策略

# Nginx负载均衡配置
upstream php_backend {
    least_conn;  # 最少连接数
    server 127.0.0.1:9001;
    server 127.0.0.1:9002;
    server 127.0.0.1:9003;
    keepalive 32;
}
server {
    listen 80;
    location ~ \.php$ {
        fastcgi_pass php_backend;
        # 其他配置...
    }
}

最佳实践总结

代码层面
- 使用OPcache并开启JIT（PHP 8+）
- 避免在循环中重复连接数据库
- 合理使用单例模式减少资源消耗
- 使用异步处理耗时任务
架构层面
- 引入消息队列处理异步任务
- 使用Redis/Memcached做缓存层
- 数据库读写分离
- 采用微服务架构拆分
运维层面
- 开启Gzip压缩
- 使用CDN加速静态资源
- 配置合理的超时时间
- 实施监控告警系统
数据库层面
- 使用连接池
- 优化SQL查询
- 添加合适索引
- 使用Redis做热点数据缓存