// Hyperf令牌桶实现
class TokenBucketLimiter
{
  private $redis;
  private $key;
  private $capacity; // 桶容量
  private $rate;    // 令牌生成速率/秒

  public function tryAcquire(): bool
  {
      $now = microtime(true);
      $data = $this->redis->hMGet($this->key, ['tokens', 'timestamp']);
      
      $tokens = floatval($data['tokens'] ?? $this->capacity);
      $lastTime = floatval($data['timestamp'] ?? $now);
      
      // 计算新增令牌
      $delta = ($now - $lastTime) * $this->rate;
      $tokens = min($this->capacity, $tokens + $delta);
      
      if ($tokens >= 1) {
          $tokens -= 1;
          $this->redis->hMSet($this->key, [
              'tokens' => $tokens,
              'timestamp' => $now
          ]);
          return true;
      }
      return false;
  }
}

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];
    }
}

// 基于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