class StockService
{
    // 库存状态转换图
    const STATE_MACHINE = [
        'available' => ['lock' => 'locked'],
        'locked' => [
            'confirm' => 'sold',
            'release' => 'available'
        ],
        'sold' => []
    ];

    // Lua脚本保证原子操作
    private $luaScript = <<<'LUA'
local key = KEYS[1]
local quantity = tonumber(ARGV[1])
local opType = ARGV[2]

local available = redis.call('HGET', key, 'available') or 0
local locked = redis.call('HGET', key, 'locked') or 0
local sold = redis.call('HGET', key, 'sold') or 0

if opType == 'lock' then
    if available < quantity then
        return {0, available, locked, sold}
    end
    redis.call('HINCRBY', key, 'available', -quantity)
    redis.call('HINCRBY', key, 'locked', quantity)
elseif opType == 'confirm' then
    -- 确认扣减逻辑
end

return {1, 
    redis.call('HGET', key, 'available'),
    redis.call('HGET', key, 'locked'),
    redis.call('HGET', key, 'sold')}
LUA;

    public function lockStock(string $skuId, int $quantity): bool
    {
        $result = Redis::eval(
            $this->luaScript, 
            ["stock:$skuId", $quantity, 'lock'], 
            1
        );
        return (bool)$result[0];
    }
}

// 协程MySQL连接池配置
class DatabasePool
{
    protected $config = [
        'driver' => 'mysql',
        'host' => '127.0.0.1',
        'port' => 3306,
        'database' => 'seckill',
        'username' => 'root',
        'password' => '',
        'charset' => 'utf8mb4',
        'collation' => 'utf8mb4_unicode_ci',
        'pool' => [
            'min_connections' => 10,
            'max_connections' => 100,
            'connect_timeout' => 10.0,
            'wait_timeout' => 3.0,
        ]
    ];
}

// 基于JSON-RPC的服务调用
class OrderServiceConsumer extends AbstractServiceClient
{
    protected $serviceName = 'OrderService';
    protected $protocol = 'jsonrpc-http';
    
    public function createOrder(array $data): array
    {
        return $this->__request(__FUNCTION__, compact('data'));
    }
}

// 服务提供者注解
#[RpcService(name: "OrderService", protocol: "jsonrpc-http", server: "jsonrpc")]
class OrderService
{
    public function createOrder(array $data): array
    {
        // 订单创建逻辑
    }
}

// 可靠消息服务
class ReliableMessageService
{
    public function sendConfirmMessage(string $topic, array $message): void
    {
        DB::transaction(function () use ($topic, $message) {
            // 1.写入本地消息表
            $messageRecord = Message::create([
                'topic' => $topic,
                'content' => json_encode($message),
                'status' => MessageStatus::PENDING
            ]);
            
            // 2.发送事务消息
            $this->producer->produce($message);
            
            // 3.更新消息状态
            $messageRecord->update(['status' => MessageStatus::SENT]);
        });
    }

    // 消息补偿任务
    #[CrontabRule("0 */5 * * * *")]
    public function compensateMessages(): void
    {
        Message::where('status', MessageStatus::PENDING)
            ->where('created_at', '<', now()->subMinutes(5))
            ->chunkById(100, function ($messages) {
                foreach ($messages as $message) {
                    $this->producer->produceAgain($message);
                }
            });
    }
}

// Prometheus指标采集
class SeckillMetrics
{
    #[Metric(name="seckill_requests_total", type="counter")]
    public function requestCounter(): Counter
    {
        return Counter::with(['status', 'sku_id'])
            ->namespace('seckill')
            ->help('Total seckill requests');
    }

    #[Metric(name="seckill_duration_seconds", type="histogram")]
    public function durationHistogram(): Histogram
    {
        return Histogram::with(['phase'])
            ->buckets([0.1, 0.5, 1.0, 2.0])
            ->namespace('seckill')
            ->help('Request processing duration');
    }
}

// 中间件埋点
class MetricsMiddleware implements MiddlewareInterface
{
    public function process(...$params)
    {
        $start = microtime(true);
        $response = $params[0]->process(...$params);
        
        $duration = microtime(true) - $start;
        $this->metrics->durationHistogram()
            ->observe($duration, ['phase' => 'process']);
            
        return $response;
    }
}

# Alertmanager配置示例
route:
  group_by: ['alertname', 'cluster']
  receiver: 'web.hook'

receivers:
- name: 'web.hook'
  webhook_configs:
  - url: 'http://alert-receiver:5000/'

inhibit_rules:
- source_match:
    severity: 'critical'
  target_match:
    severity: 'warning'
  equal: ['alertname', 'cluster']

// 基于Swoole的压测工具
class BenchmarkWorker
{
    public function run(int $concurrency, int $duration): array
    {
        $stats = new StatsCollector();
        $startTime = microtime(true);
        
        $channel = new Coroutine\Channel($concurrency);
        Coroutine::create(function () use ($channel, $stats) {
            while (true) {
                $start = microtime(true);
                try {
                    $response = $this->client->request('/seckill');
                    $stats->recordSuccess($response->getStatusCode());
                } catch (\Throwable $e) {
                    $stats->recordError($e->getCode());
                }
                $stats->recordLatency(microtime(true) - $start);
                $channel->push(true);
            }
        });

        // 运行指定时间后停止
        Coroutine::create(function () use ($startTime, $duration) {
            while (microtime(true) - $startTime < $duration) {
                Coroutine::sleep(0.1);
            }
            $this->stopAll();
        });
        
        return $stats->getReport();
    }
}

// 数据库连接池配置
'pool' => [
    'min_connections' => 20,
    'max_connections' => 200,
    'connect_timeout' => 5.0,
    'wait_timeout' => 2.0,
]

$redis->pipeline(function ($pipe) use ($skuList) {
    foreach ($skuList as $sku) {
        $pipe->hGetAll("stock:$sku");
    }
});
   

; php.ini配置
opcache.jit=1235
opcache.jit_buffer_size=256M