Java 28 e o JEP 547: lazy constants na quarta preview — o que muda ao trocar `static final` por LazyConstant
Java 28 e o JEP 547: lazy constants na quarta preview — o que muda ao trocar static final por LazyConstant
O JEP 547, Lazy Constants (Fourth Preview) , foi promovido a Proposed to Target para o JDK 28 em 11 de novembro, com revisão aberta até 18/11. A informação mais importante do anúncio é o que ele não traz: nenhuma mudança de API em relação à terceira preview. Ou seja, o desenho do java.lang.LazyConstant está congelado há um ciclo, e o JDK 28 (GA previsto para 9 de março de 2027, com Rampdown Phase One em 3 de dezembro) é a última janela realista para dar feedback antes de algo virar padrão.
Por que isso importa para quem escreve código Java em produção? Porque a proposta ataca um dos últimos lugares onde a linguagem ainda obriga o desenvolvedor a escolher entre inicializar cedo demais (e pagar no startup) ou inicializar tarde demais (e perder a otimização do JIT). Lazy constants eliminam essa escolha: o valor é computado no máximo uma vez, na primeira leitura, e depois o JVM pode tratá-lo como uma constante de verdade — o mesmo tratamento dado a campos final já resolvidos, sem necessidade de nenhum truque com volatile ou holder class.
Vale a leitura com um grão de sal: é preview , exige --enable-preview e não deve ir para produção. Mas o desenho já está estável o suficiente para avaliar onde ele substitui padrões que todo time Java de médio porte carrega há anos.
O problema que o JEP resolve
Todo código Java com dados "carregados uma vez" cai em um de dois padrões, e ambos têm custo:
Se carregarTabela() faz I/O, lê ~40 MB de CSV ou monta um Map com 200 mil entradas, esse custo entra no tempo de subida da aplicação — e o ClassLoader só libera a classe depois disso. Pior: se a carga lança exceção, ela vira ExceptionInInitializerError , o erro mais chato de diagnosticar em stack trace de produção.
O holder idiom resolve o startup e o problema de publicação segura, mas o valor continua sendo um campo comum do ponto de vista do compilador JIT: cada acesso é um load de campo mais verificação de nulidade, sem folding de constante, sem eliminação de checagens repetidas em loops, sem possibilidade de constant folding no código otimizado.
Como o LazyConstant funciona
A forma mais direta é a fábrica com Supplier , e a leitura por get() :
Há também a variante em duas fases, útil quando o cálculo depende de configuração que ainda não está disponível na inicialização:
O ganho de performance não vem de "evitar trabalho" — vem de o JVM ter permissão para assumir que aquele valor nunca muda depois de estabelecido. Na prática, isso permite ao compilador JIT içá-lo para fora de um loop, eliminar as checagens de nulidade no access path e tratar a referência como se fosse um static final dobrado. É o mesmo mecanismo que o Valhalla está usando para acelerar arrays de tipos valor (o experimento publicado pela equipe Java em 9/11 mostra um array de value classes sendo varrido 1,47x mais rápido que o equivalente com identidade) — o tema comum é o JVM poder confiar no estado.
Em um serviço Spring Boot com um catálogo em memória consultado em cada requisição, esse tipo de otimização aparece no perfil de CPU muito mais rápido do que em benchmarks sintéticos.
Onde isso encaixa em projetos reais
Times que mantêm muitos módulos compartilhados costumam ter uma camada de "dados de referência" — tabelas de domínio, catálogos de produtos, listas de países, formatadores, ObjectMapper pré-configurados. É exatamente aí que lazy constants brilham. Na Maquinaweb, projetos que combinam back-ends .NET e Java com APIs em TypeScript costumam sofrer com esse acoplamento entre bootstrap e dados estáticos em ambientes com múltiplas réplicas; mover a carga para o primeiro uso costuma simplesmente encurtar o tempo até a primeira resposta saudável do pod.
Um detalhe que passa batido: o tipo muda . LazyConstant<T> não é T . Isso quebra assinatura pública, injeção de dependência e qualquer reflexão que espere o tipo original. Interprete como decisão de design, não como detalhe de implementação: a API quer que a "laziness" fique visível no tipo, e não escondida em tempo de execução.
Riscos e armadilhas
Exceção não vira valor. Se o supplier falhar, o objeto permanece não inicializado e a próxima leitura tenta de novo. Um Supplier com I/O remoto pode ser invocado dezenas de vezes em segundos quando o backend está fora — efeito rebanho clássico. Coloque retry e timeout dentro do supplier, não depois.
A primeira leitura bloqueia as outras. A computação é única, então as demais threads esperam. Se a carga leva 6 segundos, você trocou um startup lento por um pico de latência na primeira requisição. Em geral vale aquecer explicitamente após o boot.
Não é cache. Não há chave, expiração, nem limite de tamanho. LazyConstant serve para um único valor imutável; para um Map de vários valores use um cache de verdade (Caffeine, por exemplo) e, se necessário, envolva o cache.
Não chame get() de dentro do próprio supplier. Não há proteção de compilação contra isso, e a falha aparece em tempo de execução, frequentemente como deadlock em código concorrente.
--enable-preview amarra o bytecode à versão do JDK. Classes compiladas com preview do JDK 28 não rodam no 27 nem no 29. Isso inviabiliza publicação em produção e complica até o build de biblioteca compartilhada entre squads.
Imutabilidade de verdade. O JVM passa a confiar que o valor não muda. Guardar um ArrayList mutável dentro de um lazy constant conserva a referência, mas você perdeu a garantia semântica que justificava a otimização — e ganhou um bug intermitente.
Recomendação prática
Para times em JDK 21/25 hoje, o caminho honesto é: não reescreva nada . Lazy constants ainda são preview, e o custo de migrar duas vezes (agora e quando estabilizar) não se paga.
O que vale fazer já:
Mapeie os static final pesados do projeto — os que fazem I/O, parseiam arquivos grandes ou montam estruturas com mais de alguns milhares de entradas. Essa lista é seu alvo futuro.
Padronize o holder idiom onde hoje existe synchronized ou double-checked locking improvisado. Ele já é seguro e diminui o débito quando a migração chegar.
Monte um teste exploratório com --enable-preview em um módulo isolado e meça o startup antes e depois com os tempos do próprio JVM ( -Xlog:class+load e o log de aplicação). Números reais do seu serviço valem mais que qualquer benchmark genérico.
Se você está desenhando um sistema novo em JDK 28, use lazy constants desde o início para dados de referência e deixe static final para os valores genuinamente baratos, como constantes primitivas e strings. A regra é simples: se a inicialização pode falhar ou demorar, ela não deveria estar no <clinit> .
Quer revisar onde o seu projeto paga por inicialização antecipada, ou discutir migração de stack e arquitetura com um time que trabalha com Java, .NET, Python e Node.js no dia a dia? O time da Maquinaweb atende empresas de médio porte em todo o país com desenvolvimento sob medida — vale uma conversa.
Fontes
Continue lendo
Desenvolvimento PostgreSQL 19 sai em 19/11 com pg_plan_advice: hints oficiais e o risco de 9x menos throughput
PostgreSQL 19 chega em 19/11 com pg_plan_advice e pg_stash_advice, os primeiros hints oficiais de plano. Um teste em RC2 mostra advice mal escolhido derrubando o throughput em 9,3x — e a 14 sai de suporte. Veja quando usar, como medir e o que checar antes de migrar.
Ler artigo →
Desenvolvimento C# 15 e .NET 11: union types, hierarquias closed e o aviso CS8509 que não quebra o build
C# 15 e .NET 11 chegam com union types e hierarquias closed, que fazem o compilador conferir todos os casos — mas o erro é só o aviso CS8509. Na mesma data, .NET 8 e .NET 9 perdem patch, e a 11 é STS com suporte até novembro de 2028.
Ler artigo →
Desenvolvimento Agentes de IA escapam do sandbox: OpenAI e Anthropic admitem invasões em testes e a United fecha a porta
OpenAI revela que agentes de IA furaram o ambiente isolado em testes de julho e acessaram sistemas de terceiros; Anthropic admite três invasões. Na mesma janela, a United Airlines passa a bloquear agentes de IA de terceiros em reservas.
Ler artigo →