Bem-vindo à aula sobre Performance em PHP. Nesta aula, vamos explorar como identificar e resolver gargalos de desempenho em aplicações PHP, desde a configuração do servidor até práticas de código. Você aprenderá a utilizar o OPcache para acelerar a execução, aplicar lazy loading para otimizar o uso de recursos e medir o desempenho com ferramentas adequadas.

O desempenho é crucial para a experiência do usuário e para a escalabilidade de qualquer aplicação. Em PHP, muitos problemas de lentidão podem ser evitados com boas práticas e configurações corretas. Vamos mergulhar nos principais pontos que afetam a performance e como solucioná-los.

Gargalos comuns

Gargalos de performance em PHP podem ocorrer em várias camadas: código, banco de dados, rede, servidor web e configuração do PHP. Os mais comuns incluem consultas SQL ineficientes, loops desnecessários, falta de uso de cache, carregamento excessivo de arquivos e má utilização de memória.

Um exemplo típico é executar consultas ao banco de dados dentro de loops, o que aumenta drasticamente o tempo de resposta. Outro problema é a recompilação do código PHP a cada requisição, que pode ser mitigada com o OPcache. Além disso, o uso de bibliotecas pesadas sem necessidade pode sobrecarregar a aplicação.

// Exemplo de gargalo: consulta em loop
foreach ($ids as $id) {
    $user = DB::query("SELECT * FROM users WHERE id = $id");
    // processa $user
}

// Melhor abordagem: consulta única com IN
$users = DB::query("SELECT * FROM users WHERE id IN (" . implode(',', $ids) . ")");

Para identificar gargalos, é importante usar ferramentas de profiling e monitoramento, como Xdebug, Blackfire.io ou o próprio log de slow queries do banco de dados. Muitas vezes, a otimização de uma única consulta pode melhorar significativamente o desempenho geral.

OPcache

O OPcache é uma extensão do PHP que armazena o bytecode compilado dos scripts em memória, evitando a necessidade de recompilar o código a cada requisição. Isso reduz drasticamente o tempo de execução e o uso de CPU, especialmente em aplicações grandes.

Para habilitar o OPcache, é necessário configurar o php.ini. As principais diretivas são opcache.enable, opcache.memory_consumption e opcache.max_accelerated_files. Recomenda-se definir opcache.validate_timestamps como 0 em produção para evitar verificação de arquivos a cada requisição, mas lembre-se de limpar o cache ao fazer deploy.

// Exemplo de configuração no php.ini
; opcache.enable=1
; opcache.memory_consumption=128
; opcache.max_accelerated_files=10000
; opcache.validate_timestamps=0

Além da configuração, é importante garantir que o OPcache esteja instalado. Em distribuições Linux, você pode instalar com apt install php-opcache ou yum install php-opcache. Verifique a configuração com php -m | grep opcache.

O OPcache também oferece funções como opcache_reset() para limpar o cache programaticamente, útil em scripts de deploy. Lembre-se de monitorar o uso de memória do OPcache para ajustar os parâmetros conforme necessário.

Lazy loading

Lazy loading é uma técnica que adia o carregamento de recursos até que sejam realmente necessários. No contexto PHP, isso pode ser aplicado a classes, arquivos de configuração, conexões de banco de dados e objetos pesados. O objetivo é reduzir o tempo de inicialização e o consumo de memória.

Um exemplo comum é o carregamento de classes usando autoloading (PSR-4). Com o autoload, a classe só é carregada quando é instanciada ou referenciada, evitando carregar todas as classes de uma vez. Isso é especialmente útil em frameworks grandes.

// Exemplo de lazy loading com autoload (Composer)
require 'vendor/autoload.php';

// A classe só é carregada quando usada
$user = new \App\Models\User();

Outra aplicação é o carregamento de configurações. Em vez de carregar todos os arquivos de configuração no início, você pode carregar apenas os necessários para a requisição atual. Da mesma forma, conexões com o banco de dados podem ser estabelecidas apenas quando a primeira consulta é feita, usando um padrão singleton com inicialização preguiçosa.

class Database {
    private static $instance = null;

    public static function getConnection() {
        if (self::$instance === null) {
            self::$instance = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
        }
        return self::$instance;
    }
}

Lazy loading também pode ser aplicado ao carregamento de imagens, vídeos e outros assets, mas no PHP server-side focamos em código e dados. A ideia é não fazer trabalho desnecessário antes de ser preciso.

Medindo

Para otimizar, é essencial medir. Existem várias ferramentas e técnicas para medir o desempenho de aplicações PHP. As principais são: profiling com Xdebug, benchmarks com ferramentas como ApacheBench (ab) ou wrk, e monitoramento de logs.

O Xdebug é uma extensão que gera relatórios de profiling, mostrando quanto tempo cada função leva. Isso ajuda a identificar pontos quentes no código. Para usar, você precisa configurar o Xdebug no php.ini e analisar os arquivos gerados com ferramentas como Qcachegrind ou Webgrind.

// Exemplo de configuração do Xdebug no php.ini
; zend_extension=xdebug.so
; xdebug.mode=profile
; xdebug.output_dir="/tmp/profiling"

Para benchmarks de requisições, você pode usar o ApacheBench:

ab -n 1000 -c 10 http://localhost/index.php

Além disso, é importante monitorar o tempo de execução de consultas no banco de dados. O MySQL, por exemplo, tem o log de slow queries que pode ser ativado. Analisar esses logs ajuda a encontrar consultas ineficientes.

Outra métrica importante é o uso de memória. Você pode usar memory_get_peak_usage() em pontos críticos do código para verificar o consumo. Com base nas medições, você pode priorizar otimizações que tragam maior impacto.

Boas práticas e observações finais

Além das técnicas abordadas, é importante seguir boas práticas de programação: evitar código redundante, usar cache de dados (como Redis ou Memcached), otimizar consultas SQL com índices, e manter o código organizado. Sempre meça antes e depois de cada mudança para garantir que a otimização realmente melhora o desempenho.

Lembre-se de que a performance é um processo contínuo. Monitore sua aplicação regularmente e esteja atento a novos gargalos. Use ferramentas de observabilidade, como New Relic ou Datadog, para ter uma visão abrangente. Com as técnicas desta aula, você está preparado para tornar suas aplicações PHP mais rápidas e eficientes.

Referências

Exercícios

  1. Identifique o gargalo: Dado o código abaixo, qual é o problema de performance e como você o corrigiria?
    $products = DB::query('SELECT * FROM products');
foreach ($products as $product) {
    $reviews = DB::query("SELECT * FROM reviews WHERE product_id = " . $product['id']);
    $product['reviews'] = $reviews;
}

    ✓ Resposta: O problema é a consulta ao banco de dados dentro do loop, causando N+1 consultas. Para corrigir, use uma única consulta com JOIN ou IN para obter todas as reviews de uma vez.
    $products = DB::query('SELECT * FROM products');
$productIds = array_column($products, 'id');
$reviews = DB::query("SELECT * FROM reviews WHERE product_id IN (" . implode(',', $productIds) . ")");
// Agrupa reviews por product_id e associa aos produtos
  2. OPcache: Explique o que é o OPcache e como ele melhora a performance. Liste duas diretivas de configuração importantes.

    ✓ Resposta: O OPcache armazena o bytecode compilado dos scripts PHP em memória, evitando a recompilação a cada requisição. Isso reduz o tempo de execução e o uso de CPU. Diretivas importantes: opcache.enable (liga/desliga) e opcache.memory_consumption (define a memória alocada).
  3. Lazy loading: Escreva um exemplo de lazy loading para uma classe de configuração que carrega um arquivo JSON apenas quando necessário.

    ✓ Resposta: 
    class Config {
    private static $data = null;

    public static function get($key) {
        if (self::$data === null) {
            self::$data = json_decode(file_get_contents('config.json'), true);
        }
        return self::$data[$key] ?? null;
    }
}
  4. Medindo: Que ferramenta você usaria para identificar qual função está consumindo mais tempo em um script PHP? Descreva brevemente como usá-la.

    ✓ Resposta: Usaria o Xdebug com profiling. Configuro o Xdebug no php.ini com xdebug.mode=profile, executo o script e analiso o arquivo gerado com Qcachegrind ou Webgrind para ver o tempo gasto em cada função.
  5. Otimização: Qual é a vantagem de usar lazy loading em uma aplicação PHP? Dê um exemplo além dos mencionados na aula.

    ✓ Resposta: A vantagem é reduzir o uso de memória e o tempo de inicialização, carregando recursos apenas quando necessários. Exemplo: carregar um serviço de terceiros (como um SDK de pagamento) somente quando o usuário acessa a página de checkout, em vez de carregar em todas as requisições.