Fale conosco
Desenvolvimento

JDK 28: LazyConstant em quarto preview e o que isso muda no seu código de inicialização

27 min de leitura
JDK 28: LazyConstant em quarto preview e o que isso muda no seu código de inicialização

JDK 28: LazyConstant em quarto preview e o que isso muda no seu código de inicialização

O JEP 547, Lazy Constants (Fourth Preview) , foi elevado a Proposed to Target para o JDK 28 em 11 de novembro, com revisão encerrada em 18 de novembro. A proposta é assinada por Per Minborg e Maurizio Cimadamore e não altera uma linha da API que já rodou nos previews do JDK 25, 26 e 27 — e é justamente esse detalhe que interessa a quem mantém código: o desenho estabilizou, mas o recurso continua em preview, o que significa --enable-preview em compilação e execução e nenhuma garantia de binário compatível entre versões.

O problema que ele resolve é velho conhecido de quem já abriu um heap dump: inicialização tardia em Java nunca foi gratuita. Ou você paga com volatile e double-checked locking, ou com uma classe holder só para o idioma de inicialização sob demanda, ou aceita inicializar tudo no startup e convive com os 6 a 8 segundos a mais que um único static final mal colocado pode custar — inclusive em serviços que só usam aquela estrutura em um endpoint de exceção.

O LazyConstant entra no meio: um objeto que guarda um valor imutável, calculado no máximo uma vez, mas que o JVM trata como constante de verdade.

O antes e o depois

O padrão clássico, ainda onipresente em bases Spring e Jakarta EE:

Com a API de preview, o mesmo comportamento em uma linha:

A API tem quatro operações que cobrem quase todo uso: of(Supplier) constrói, get() materializa o valor, orElse(T) devolve um padrão de fallback sem disparar o cálculo, computeIfAbsent(T) grava um valor só se ele ainda não existir, e isInitialized() permite decidir sem efeito colateral. Esse último trio é o que separa o LazyConstant de um Supplier memorizado: você consegue inspecionar e preencher o valor de fora, o que ajuda em testes e em fluxos de configuração.

Por que o JVM consegue tratar como constante

A palavra "lazy constant" não é marketing: se o campo que carrega o LazyConstant é final , o HotSpot pode aplicar ao resultado as mesmas otimizações que aplica a um static final primitivo. Depois de inicializado, get() deixa de ser um caminho de memória com barreira de sincronização e passa a ser um valor que o compilador JIT pode dobrar, propagar entre chamadas e usar para eliminar ramificações e desvirtualizar chamadas.

É a mesma ideia que sustentava StableValue no JDK 25, renomeada para LazyConstant no JDK 26. Três previews depois, a mecânica estável e o ganho é concreto: você escreve código com um campo mutável em essência, e o runtime recompensa com o comportamento de um campo imutável. Em projeto de cliente com muita leitura de catálogo e tabelas de referência carregadas na inicialização, esse tipo de substituição costuma aparecer menos no throughput bruto e mais no tempo de startup e no consumo de heap de curta duração — vale medir, não presumir.

Onde ele encaixa e onde não encaixa

Um bom critério de triagem para o seu backlog:

Encapsula bem: Pattern compilado, schema JSON parseado, Map de lookup carregado de banco, metadados de pool de conexão, clientes HTTP construídos uma vez, tabelas de tradução.

Substitui com vantagem: double-checked locking escrito na mão, idiom holder class, campos volatile que só existem para publicação segura.

Não substitui: cache com expiração, invalidação ou limite de tamanho — para isso continue com Caffeine ou similar. O LazyConstant não esquece, não expira e não aceita política de despejo.

Não substitui @Lazy do Spring: o escopo do bean e o ciclo de vida do contêiner continuam sendo outro problema. O que muda é que, dentro de um bean, você deixa de precisar de sincronização manual.

Há também a variante para coleções: List.ofLazy , Set.ofLazy e Map.ofLazy produzem coleções imutáveis cujos elementos são computados sob demanda, cada um no seu tempo. É o encaixe natural para menus de configuração e tabelas de feature flags em que só uma fração das entradas é lida por request — e onde a inicialização ansiosa de todas elas custa memória sem retorno.

Na Maquinaweb, que trabalha com times de backend em Java e .NET em projetos sob medida e de integração de sistemas, esse tipo de decisão costuma aparecer na fase de revisão de arquitetura, não na de codificação: trocar inicialização ansiosa por tardia muda o perfil de startup da aplicação e o comportamento do primeiro request depois de um deploy — e é aí que a escolha precisa estar documentada.

Riscos e armadilhas

Preview é preview. O recurso já passou por JDK 25, 26, 27 e agora 28 sem virar final. Isso significa --enable-preview em javac e em java , e classes compiladas com preview não rodam em outra versão do JDK. Se você está no JDK 25 LTS — o destino mais provável da maioria dos times de produção —, o LazyConstant só chega à sua linha de suporte com o JDK 29. A recomendação é estudar agora, experimentar em spike isolado e não expor LazyConstant na assinatura pública de uma biblioteca interna: o tipo ainda pode mudar e você ficaria preso a uma versão.

Exceção na função de cálculo. Se o Supplier lançar exceção, o valor continua não inicializado e a exceção chega a quem chamou get() . A consequência prática é que a função pode ser executada mais de uma vez — em caso de falha, não em caso de sucesso. Cálculo com efeito colateral (gravar métrica, abrir arquivo, registrar em log) vai duplicar. Mantenha a função pura e idempotente.

Recursão e deadlock. Chamar get() de dentro da própria função de cálculo, direta ou indiretamente por uma cadeia de dependências, trava ou estoura. Vale revisar o grafo de dependências dos seus holders .

Campo não final . O ganho de constante depende de o campo ser final . Um LazyConstant guardado em campo mutável funciona, mas perde a dobra de constantes — você paga o custo do objeto sem o benefício.

null e igualdade. O LazyConstant guarda um valor, não é o valor: compare com get() e não com equals no invólucro. E lembre que ele não é um Optional — orElse aqui é fallback, não ausência.

Recomendação prática

Para times em JDK 25 LTS, o caminho é de baixo risco: identifique os static final caros no caminho de startup, meça o tempo de boot antes e depois, e implemente a inicialização tardia hoje com o idiom holder ou com LazyConstant encapsulado atrás de um método privado. Quando o JDK que você usa oficialmente expuser a API, a troca fica restrita a esse método, sem tocar no restante do código.

Se o seu time está avaliando migração de stack, revisão de arquitetura de backend ou um projeto novo em que o tempo de startup e o consumo de memória pesam no custo de infraestrutura, vale conversar com o time da Maquinaweb: dá para desenhar essa camada de inicialização com o JDK atual e deixar o caminho pronto para o preview virar final.

Fontes

#Java #JDK 28 #LazyConstant #JEP 547 #concorrência #JVM #inicialização tardia #performance #preview
Contato

Bora conversar?

Três campos. A resposta vem no WhatsApp.

Ou escreva para contato@maquinaweb.com.br.

Você vai para o WhatsApp com a mensagem pronta. Sem spam, sem lista.

Seus dados seguem a nossa política de privacidade.