Destaques do Go 1.26: Green Tea GC, Modernizadores do go fix e Ajustes de Linguagem
Go 1.26 (fevereiro de 2026) é um lançamento de toolchain onde o runtime e as ferramentas de desenvolvedor importam tanto quanto a sintaxe.
//
Busque em todas as páginas da documentação
Go 1.26 (fevereiro de 2026) é um lançamento de toolchain onde o runtime e as ferramentas de desenvolvedor importam tanto quanto a sintaxe.
O Green Tea GC reduz a sobrecarga do coletor por padrão.
O go fix tornou-se um pipeline de modernização com um clique.
Pequenos ajustes de linguagem como new(expr) removem anos de boilerplate de funções auxiliares.
O Go 1.26 lança o Green Tea GC como o coletor de lixo padrão, um go fix reconstruído com modernizadores e melhorias direcionadas na linguagem/stdlib.
As PMEs devem planejar as atualizações em torno da validação de latência do GC, refatorações idiomáticas automatizadas e padrões de struct de campo opcional.
Recursos experimentais (perfis de vazamento de goroutine, simd/archsimd, runtime/secret) existem para os primeiros adotantes, mas não são necessários para a maioria dos serviços.
Cartão de atualização de referência rápida para Go 1.26.
# 1. Atualizar a versão da linguagem do módulo
go get go@1.26.0 && go mod tidy
# 2. Visualizar modernizadores
go fix -diff ./...
# 3. Aplicar e testar (executar duas vezes para correções sinérgicas)
go fix ./... && go test ./...
go fix ./... && go test ./...
# 4. Reverter GC apenas se estiver investigando regressão
GOEXPERIMENT=nogreenteagc go build -o app ./cmd/appQuando usar isso:
runtime.gcCampos de API opcionais com new(expr), em seguida, modernizar o código circundante com go fix.
package api
import (
"encoding/json"
"time"
)
type Person struct {
Name string `json:"name"`
Age *int `json:"age,omitempty"`
}
func PersonJSON(name string, born time.Time) ([]byte, error) {
return json.Marshal(Person{
Name: name,
Age: new(yearsSince(born)), // Go 1.26: new aceita expressões
})
}
func yearsSince(t time.Time) int {
return int(time.Since(t).Hours() / (365.25 * 24))
}# Após atualizar go.mod para 1.26:
go fix -newexpr ./...
go fix -stringscut -minmax ./...
go vet ./...
go test ./...// Antes do go fix (estilo antigo) - modernizadores podem reescrever:
// eq := strings.IndexByte(pair, '=')
// result[pair[:eq]] = pair[1+eq:]
// Após o modernizador stringscut:
// before, after, _ := strings.Cut(pair, "=")
// result[before] = afterO que isso demonstra:
new(expr) remove helpers do tipo newInt para campos de ponteiro opcionaisgo fix -newexpr reescreve helpers e locais de chamada entre pacotesstringscut, minmax, mapsloop) são executados no mesmo comandogo vet ainda detecta problemas que os modernizadores não abordamO Green Tea substitui a fase clássica de marcação de inundação de grafo por objeto por escaneamento orientado a página.
Em vez de saltar entre objetos pequenos espalhados, o coletor acumula trabalho por página de heap, escaneando objetos em ordem de memória.
Benefícios:
Benchmarks variam; muitos programas veem 10-40% menos tempo de CPU do GC, com ~10% como um caso comum.
Em hardware amd64 mais recente, um adicional de ~10% de melhoria do GC é esperado de instruções vetoriais.
Rollback: GOEXPERIMENT=nogreenteagc no momento da compilação.
A desativação deve ser removida no Go 1.27.
Valide a latência p99 e as frações de GC de runtime/metrics após a atualização.
O Go 1.26 reescreveu o go fix no framework golang.org/x/tools/go/analysis compartilhado com go vet.
Os fixadores devem ser preservadores de comportamento (melhorias de desempenho e estilo permitidas).
Dezenas de modernizadores são enviados, incluindo:
| Analisador | O que faz |
|---|---|
any | interface{} -> any |
minmax | cadeias if -> min/max |
mapsloop | loops de mapa manuais -> pacote maps |
stringscut | Index+slice -> strings.Cut |
forvar | remove o shadowing de loop x := x pré-1.22 |
newexpr | wrappers de helper -> new(expr) |
inline | aplica migrações de API //go:fix inline |
Dicas de fluxo de trabalho:
go fix-diff primeiro em repositórios grandesgo fix -minmax ./...) para dividir a carga de revisãominmax e depois min aninhado) aparecem na segunda passagemListar analisadores: go tool fix help
new(expr) - new agora aceita expressões, não apenas tipos.
Crítico para campos de ponteiro opcionais em modelos JSON, protobuf e de banco de dados.
Restrições genéricas auto-referenciais - tipos genéricos podem se referenciar em listas de restrições, permitindo padrões como Adder[A Adder[A]].
GOEXPERIMENT=norandomizedheapbase64)GOEXPERIMENT=goroutineleakprofileerrors.AsType helper genéricolog/slog.NewMultiHandler para logging de fan-out# Matriz de CI: execute go fix sob GOOS/GOARCH representativo se você usar tags de compilação
GOOS=linux GOARCH=amd64 go fix ./...
GOOS=darwin GOARCH=arm64 go fix ./...nogreenteagc apenas enquanto investiga.go fix em uma única passagem em repositórios enormes - Correções sinérgicas e de limpeza de importação precisam de uma segunda execução. Correção: Execute go fix ./... duas vezes; corrija erros de compilação de conflitos semânticos manualmente.go - Os modernizadores dependem da versão efetiva do Go. Correção: Execute go get go@1.26.0 antes de esperar correções de newexpr.new sombreado - newexpr ignora reescritas inseguras quando new é redeclarado localmente. Correção: Renomeie os vínculos locais de new antes de executar o fixer.vet após fix - Modernizadores não detectam bugs lógicos. Correção: Mantenha go vet e testes de integração no pipeline de atualização.| Alternativa | Usar Quando | Não Usar Quando |
|---|---|---|
GOEXPERIMENT=nogreenteagc | Suspeita de regressão do GC durante a fase canary | Estratégia de produção a longo prazo (remoção em 1.27) |
| Apenas correções rápidas do gopls | Arquivos ativos pequenos no IDE | Atualização de repositório inteiro após a atualização da toolchain |
| Refatoração manual | Caminhos de código críticos que exigem design humano | Centenas de atualizações de idioma repetitivas |
Permanecer no Go 1.25 + experimento greenteagc | Precisa de tempo antes da adoção completa do 1.26 | Você deseja GC acelerado por vetor e o conjunto go fix |
Um coletor de lixo de fase de marcação orientado a página que melhora a localidade ao escanear objetos pequenos.
Padrão no Go 1.26 após experimentação no Go 1.25.
Depende da taxa de alocação e da distribuição do tamanho do objeto.
Muitas cargas de trabalho veem 10-40% menos CPU do GC; a aceleração geral do aplicativo é geralmente menor que a fração do GC.
Fixadores históricos foram removidos como obsoletos.
O go fix do Go 1.26 usa o framework de análise moderno e os modernizadores.
Execute em branches de atualização, não em cada PR.
Trate a saída como gofmt: revise o commit de modernização dedicado.
Helpers como func intPtr(v int) *int { return &v } e chamadas de wrapper estilo protobuf para literais simples.
Projetados para preservar o comportamento; casos extremos podem causar erros de compilação (por exemplo, locais não utilizados).
Sempre execute testes após corrigir.
Uma diretiva do proprietário da API para o analisador inline migrar chamadores para funções renomeadas ou refatoradas automaticamente.
Esperado no Go 1.27 de acordo com as notas de lançamento.
Planeje validar o Green Tea antes disso.
Sim.
O Go 1.26 requer Go 1.24.6 ou posterior para compilar a própria toolchain.
Perfil de vazamento de goroutine no CI de staging se você luta contra incidentes de goroutine vazada.
Pule simd/archsimd a menos que você tenha caminhos numéricos críticos e experiência em hardware.
Versões de Stack: Esta página foi escrita para Go 1.26.x (Green Tea GC padrão, modernizadores go fix - verifique o patch na compilação), chi (última - verifique na compilação), gin (última - verifique na compilação), echo (última - verifique na compilação), google.golang.org/grpc (última - verifique na compilação), sigs.k8s.io/controller-runtime (última - verifique na compilação), kubebuilder (última - verifique na compilação), tinygo (última - verifique os alvos de placa na compilação), wazero (última - verifique na compilação) e golangci-lint (última - verifique o conjunto de linters na compilação).
Revisado por Chris St. John·Última atualização: 16 de jul. de 2026