CS Fundamentals Trainer · Guias

TCP na prática: conexões, latência, timeouts e o que quebra em produção

O que o TCP promete e o que não promete, quanto custa uma conexão (handshakes, TLS, partida lenta, janelas), a pausa de 40 ms do algoritmo de Nagle com ACKs atrasados, TIME_WAIT e esgotamento de portas, o backlog de accept, conexões semiabertas, keepalive e timeouts, com medições de experimentos em loopback e uma tabela de sintomas para diagnosticar problemas em produção.

32 min de leitura

Uma requisição que normalmente leva 2 milissegundos às vezes leva 44. Um serviço que aguentava bem a carga na segunda-feira começa a falhar na terça com "cannot assign requested address". Uma verificação de saúde passa enquanto os usuários veem timeouts. Cada um desses casos tem o mesmo tipo de causa: a aplicação tratou a rede como uma chamada de função, e o TCP, o protocolo por baixo de quase tudo, se comporta de formas que uma chamada de função não se comporta. O TCP é confiável e ordenado, mas também é um fluxo de bytes com um custo de partida, uma memória, temporizadores e limites, e são essas as coisas que aparecem em produção.

Este guia explica o TCP do ponto de vista de quem escreve e opera serviços: quanto custa uma conexão, o que decide a velocidade com que os dados se movem, a clássica pausa de 40 milissegundos (o algoritmo de Nagle encontrando as confirmações atrasadas), o que é o estado TIME_WAIT e quando ele esgota as portas de um serviço, o que acontece quando um servidor não consegue acompanhar as novas conexões e como perceber que o outro lado desapareceu. Vários desses pontos foram medidos em uma máquina real, e o código está no apêndice.

Uma nota sobre as medições. Os números marcados como "medido" vêm de programas em Go 1.24 em uma pequena VM na nuvem (2 vCPUs de um Intel Xeon a 2,1 GHz, 8 GB de memória, Linux 6 com as configurações padrão de TCP, exceto onde indicado), conversando pela interface de loopback. O loopback não tem distância nem perda de pacotes, então mostra o custo do protocolo e do kernel, não o custo de uma rede real. Esse é o objetivo de usá-lo: ele isola o comportamento (uma pausa, um limite, um temporizador) do ruído de uma rede. Onde a distância importa, o guia usa aritmética que você pode conferir, e diz isso.

1. O que o TCP promete, e o que não promete

O TCP oferece à aplicação um fluxo de bytes confiável e ordenado entre dois pontos. Se os bytes chegam, chegam uma vez e em ordem; pacotes perdidos são retransmitidos; um remetente rápido demais é desacelerado. Quatro consequências disso costumam ser esquecidas:

2. A vida de uma conexão

Diagram: A TCP connection from open to close

Os estados que importam na prática:

EstadoSignificadoSe você vir muitos deles
LISTENo servidor espera conexõesnormal
SYN_SENT / SYN_RECVum handshake está em andamentouma enxurrada de novas conexões, ou um servidor sobrecarregado (seção 8)
ESTABLISHEDaberta, os dados podem fluirnormal; conte-as para dimensionar uma camada de conexões
FIN_WAIT, CLOSINGeste lado fechou e espera o paro par demora a fechar, ou está inacessível
TIME_WAITeste lado fechou primeiro e a conexão é mantida por 60 smuitas conexões curtas (seção 7)
CLOSE_WAITo par fechou, e o programa local nãoum bug: a aplicação não está fechando seus sockets

O CLOSE_WAIT merece menção especial. Ele significa que o outro lado terminou e este programa nunca chamou close. Os sockets ficam para sempre, e os descritores de arquivo vão acabando devagar. Nunca é um problema de rede, sempre um vazamento no programa, tipicamente um close ou defer ausente em um caminho de erro.

3. Quanto custa uma nova conexão

Abrir uma conexão custa uma ida e volta antes que o primeiro byte da requisição possa ser enviado e, com TLS, uma ou mais idas e voltas a mais. A distância multiplica isso. A tabela é aritmética: uma resposta chega depois do número de idas e voltas indicado (a própria requisição leva uma).

Tempo de ida e voltaConexão reutilizadaNova conexão TCPNova conexão TCP + handshake TLS 1.3 completo
1 ms (mesmo data center)1 ms2 ms3 ms
10 ms (mesma região)10 ms20 ms30 ms
50 ms (através de um continente)50 ms100 ms150 ms
100 ms100 ms200 ms300 ms
200 ms (intercontinental, celular)200 ms400 ms600 ms

Há também um custo de CPU e de kernel que não depende da distância. Medido no loopback, uma requisição de um byte levou 9,5 microssegundos em uma conexão reutilizada e 68,5 microssegundos quando uma nova conexão foi aberta e fechada a cada requisição: 7,2 vezes mais lento, sem rede nenhuma. (O TLS acrescenta verificação de certificado e troca de chaves, que custam muito mais.)

A consequência é a regra operacional mais importante sobre o TCP: não abra uma conexão por requisição. Use pools de conexões para bancos de dados e para clientes HTTP, o keep-alive do HTTP (o padrão no HTTP/1.1) ou a multiplexação do HTTP/2, e a retomada de sessão TLS. Um serviço que fala com dez outros serviços deve manter conexões de longa duração com cada um. Um cliente HTTP criado e descartado a cada chamada é um bug de desempenho muito comum, e também o caminho habitual para o esgotamento de portas da seção 7.

4. A velocidade dos dados: janelas, partida lenta e o produto banda-atraso

O TCP limita quantos dados podem estar em trânsito, enviados mas ainda não confirmados. Dois limites se aplicam: a janela de recepção (quanto espaço o receptor tem, anunciado em cada confirmação) e a janela de congestionamento (quanto o remetente acredita que a rede consegue carregar). A menor das duas decide a velocidade.

Isso dá um teto rígido que nada tem a ver com a capacidade do enlace: vazão ≤ janela ÷ tempo de ida e volta. Com uma janela de 64 KB e uma ida e volta de 50 ms, no máximo 64 KB podem ser enviados a cada 50 ms, ou seja, 1,3 MB/s, ou cerca de 10 Mbit/s, mesmo em um enlace de 10 Gbit/s. Para encher um enlace, a janela precisa ser tão grande quanto o produto banda-atraso, largura de banda × tempo de ida e volta: um caminho de 1 Gbit/s com ida e volta de 50 ms comporta 6,25 MB em trânsito. Sistemas modernos escalam a janela automaticamente (a opção de escala de janela e o ajuste automático de buffers), mas o limite aparece com um buffer configurado pequeno, com um receptor que lê devagar e em transferências de longa distância.

As novas conexões também começam com uma janela de congestionamento pequena e a aumentam a cada ida e volta, uma fase chamada partida lenta (slow start). O tamanho inicial comum é de 10 segmentos (cerca de 14,6 KB), e ele praticamente dobra a cada ida e volta enquanto nada se perde. Contando as idas e voltas necessárias para uma resposta a partir de uma conexão fria:

Tamanho da respostaIdas e voltas (janela inicial de 10 segmentos, dobrando, sem perda)
15 KB2
100 KB3
1 MB7
10 MB10

Com 100 ms de tempo de ida e volta, uma resposta de 1 MB sobre uma conexão novinha gasta 700 ms só para ganhar velocidade, antes mesmo de a largura de banda importar. Esse é um segundo motivo, depois do handshake, para reutilizar conexões: uma conexão aquecida já fez crescer a sua janela. (O Linux pode reiniciar a janela depois de um período de inatividade, e é por isso que uma conexão de um pool que ficou parada por um tempo pode voltar a ficar lenta; verifique a configuração tcp_slow_start_after_idle nos seus hosts.)

O controle de congestionamento, o algoritmo que decide como a janela cresce e diminui diante de perda ou atraso, é uma configuração do kernel. Hosts Linux costumam usar o CUBIC, e a VM desta medição estava configurada com BBR. Você raramente o ajusta, mas ele explica por que a mesma transferência se comporta de forma diferente em hosts diferentes.

5. A pausa de 40 milissegundos: o algoritmo de Nagle e as confirmações atrasadas

Duas otimizações sensatas, uma de cada lado, se combinam em uma patologia famosa.

Agora pegue um cliente que envia uma requisição como duas escritas pequenas, um cabeçalho de 4 bytes e depois um corpo de 100 bytes, e espera a resposta:

Diagram: Nagle plus delayed ACK: the stall

O cliente espera uma confirmação antes de enviar o corpo, e o servidor espera o corpo (ou um temporizador) antes de confirmar. Nada se perde, e nada é rápido: a requisição passa cerca de 40 ms em um impasse que o temporizador de atraso desfaz.

Medido no loopback, 300 requisições em uma conexão, cada uma enviada como write(4 bytes), write(100 bytes), e então a espera de uma resposta de um byte:

ConfiguraçãoMédia por requisiçãoPercentil 99
Nagle ativado (o socket padrão), duas escritas44,02 ms47,32 ms
TCP_NODELAY, duas escritas0,02 ms0,05 ms
Nagle ativado, uma escrita de 104 bytes0,01 ms0,04 ms

Os mesmos bytes, a mesma máquina e um fator de dois mil entre a primeira linha e as outras. Um serviço com esse padrão mostra uma latência suspeitosamente presa em redondos 40 ms (ou um múltiplo) e uma CPU ociosa.

Há duas correções, e a segunda é melhor:

  1. Defina TCP_NODELAY no socket, o que desliga o Nagle. O Go faz isso por padrão em conexões TCP; muitos outros ambientes de execução e bibliotecas não fazem, então verifique o que você usa. O custo é mais pacotes pequenos se o programa escrever em muitos pedaços minúsculos.
  2. Não faça várias escritas pequenas para uma mensagem. Monte a mensagem inteira em um buffer (um escritor com buffer, ou reúna as partes em uma única escrita) e envie de uma vez. Isso é mais rápido em qualquer configuração: menos chamadas de sistema, menos pacotes e nenhuma interação com os temporizadores.

O padrão a observar tem nome, write-write-read: duas escritas seguidas e depois a espera da resposta. Ele é comum em código que envia um cabeçalho e um corpo separadamente, em implementações de protocolo escritas direto a partir de uma especificação e em clientes que descarregam um escritor com buffer no meio de uma mensagem.

6. Um fluxo não tem mensagens: enquadramento

Como o TCP é um fluxo, a aplicação precisa marcar onde uma mensagem termina. Protocolos reais fazem isso de três maneiras: um prefixo de tamanho (a mensagem começa com o seu tamanho, como na maioria dos protocolos binários e no Content-Length do HTTP), um delimitador (uma quebra de linha ou uma sequência especial de bytes, como em protocolos baseados em linhas, com escape se o delimitador puder ocorrer nos dados) ou um tamanho fixo. Um prefixo de tamanho é o mais simples e o mais seguro. O código abaixo mostra os três hábitos que importam: ler exatamente o número de bytes de que você precisa (io.ReadFull, porque um único Read pode devolver menos), recusar tamanhos absurdos antes de alocar memória e escrever o tamanho e o conteúdo com uma única escrita.

const maxMessage = 1 << 20

// readMessage reads one message that is sent as a 4-byte length followed by that many bytes.
func readMessage(r io.Reader) ([]byte, error) {
	var n uint32
	if err := binary.Read(r, binary.BigEndian, &n); err != nil {
		return nil, err
	}
	if n > maxMessage { // never trust a length that came from the network
		return nil, errors.New("message too large")
	}
	buf := make([]byte, n)
	_, err := io.ReadFull(r, buf) // Read may return fewer bytes than asked; ReadFull loops until it has all of them
	return buf, err
}

// writeMessage sends the length and the payload with one write, so Nagle's algorithm never holds back the second half.
func writeMessage(w io.Writer, payload []byte) error {
	buf := make([]byte, 4+len(payload))
	binary.BigEndian.PutUint32(buf, uint32(len(payload)))
	copy(buf[4:], payload)
	_, err := w.Write(buf)
	return err
}

func call(addr string, payload []byte) ([]byte, error) {
	d := net.Dialer{
		Timeout:   3 * time.Second,  // the handshake
		KeepAlive: 30 * time.Second, // probes on an idle connection, well below a load balancer's idle timeout
	}
	c, err := d.Dial("tcp", addr)
	if err != nil {
		return nil, err
	}
	defer c.Close()
	c.SetDeadline(time.Now().Add(5 * time.Second)) // one limit for the whole exchange
	if err := writeMessage(c, payload); err != nil {
		return nil, err
	}
	return readMessage(bufio.NewReader(c))
}

(A listagem compila; é uma ilustração, não um protocolo completo.) O mesmo exemplo mostra a forma correta de definir limites em uma conexão, que é o assunto das próximas seções: um timeout de discagem, um período de keep-alive e um prazo para a troca inteira.

7. Fechando conexões: TIME_WAIT e o esgotamento de portas

Quando uma conexão é fechada de forma ordenada, o lado que fecha primeiro não a esquece de imediato. Ele mantém a conexão no estado TIME_WAIT por duas vezes o tempo máximo de vida de um segmento, que é de 60 segundos no Linux. O motivo é sólido: um pacote duplicado e atrasado da conexão antiga não pode ser tomado como parte de uma nova conexão com os mesmos endereços e portas, e a confirmação final pode ter se perdido e precisar ser reenviada.

Um socket em TIME_WAIT custa pouca memória, mas ocupa a sua porta local em relação àquele destino durante todos os 60 segundos. Um cliente que se conecta a um endereço de servidor tem cerca de 28.000 portas efêmeras (nesta máquina a faixa é de 32768 a 60999, 28.232 portas). Se 28.232 portas ficam presas por 60 segundos cada, o teto é de cerca de 470 novas conexões por segundo para um destino. Além disso, connect falha com "cannot assign requested address".

Medido no loopback, um cliente abriu 40.000 conexões curtas para um endereço, fechando cada uma primeiro. Com a configuração que permite ao kernel reutilizar portas em TIME_WAIT desligada:

ConfiguraçãoConexões tentadasFalhasSockets em TIME_WAIT depois
Reutilização de portas em TIME_WAIT desligada40.0008.091 ("cannot assign requested address")16.774
Padrão do Linux neste host (reutilização só para loopback)40.000020.405

A configuração padrão esconde o problema no loopback, e é por isso que um teste em uma máquina passa e a produção falha: o kernel aplica a regra de reutilização somente ao loopback, então o mesmo código falando com um servidor remoto de verdade bate no limite de portas. Nas duas execuções, dezenas de milhares de sockets estavam em TIME_WAIT no final. (O número de falhas fica abaixo das 11.768 conexões além da faixa de portas porque sockets em TIME_WAIT do início da execução expiraram enquanto ela ainda corria.)

O que fazer, em ordem de preferência:

  1. Reutilizar conexões (seção 3). Um pool transforma milhares de conexões por segundo em algumas dezenas.
  2. Distribuir entre mais destinos ou endereços de origem se você realmente precisa de uma taxa de conexões muito alta: o limite se aplica por combinação de endereços e porta de destino.
  3. Deixar o outro lado fechar primeiro quando você controla o protocolo. O TIME_WAIT fica com o lado que fecha primeiro; em um protocolo em que o servidor pode enviar "terminei" e fechar, o cliente é poupado. (Para servidores, sockets em TIME_WAIT não consomem portas da mesma maneira, porque cada cliente tem um endereço diferente.)
  4. Ampliar a faixa de portas efêmeras, um paliativo que move o teto sem remover a causa.
  5. Não "conserte" encurtando o TIME_WAIT nem com opções perigosas que o ignoram (o tcp_tw_recycle foi removido do Linux porque quebrava conexões atrás de NAT). O estado existe por uma razão.

Uma configuração relacionada e inofensiva: servidores que reiniciam e não conseguem se associar à porta por causa de conexões antigas precisam de SO_REUSEADDR no socket de escuta, que a maioria das bibliotecas de servidor define por você.

8. Quando o servidor não acompanha: o backlog de accept

Um servidor que escuta mantém duas filas para cada socket de escuta: conexões que ainda estão fazendo o handshake e conexões que completaram o handshake mas ainda não foram pegas pelo accept do programa. A segunda fila tem um comprimento limitado, o backlog. Se o programa está ocupado demais para chamar accept com rapidez suficiente (um laço de eventos bloqueado, um pool de threads esgotado), a fila enche, e os handshakes seguintes são ignorados. O cliente não recebe um erro. O seu kernel simplesmente retransmite o primeiro pacote depois de um temporizador: 1 segundo, depois mais 2, depois mais 4, e assim por diante.

Medido: um servidor que escuta com um backlog de 1 e só começa a aceitar 2,5 segundos depois. Quatro clientes se conectam um após o outro.

ClientePediu emConectou depois de
10,00 s0,000 s (a fila tinha espaço)
20,00 s0,000 s (a fila tinha espaço)
30,00 s3,061 s
43,06 s0,000 s

A conexão 3 encontrou a fila cheia no segundo 0. O servidor começou a aceitar em 2,5 segundos, mas o cliente esperava o seu temporizador de retransmissão, que disparou em 1 segundo (fila ainda cheia) e em 3 segundos (sucesso). Um servidor que se recupera ainda deixa alguns clientes esperando por um temporizador de retransmissão, então a sobrecarga aparece como degraus de latência de 1 s, 3 s, 7 s e como timeouts, enquanto os gráficos do próprio servidor mostram carga baixa e respostas rápidas para as requisições que ele processou. As requisições que nunca entraram são invisíveis para as suas métricas.

O que observar e fazer:

9. Saber que o outro lado sumiu: keepalive, timeouts e conexões semiabertas

Se um par cai de forma limpa, o sistema operacional fecha os seus sockets e envia um FIN ou RST, e você fica sabendo. Se uma máquina perde energia, é particionada, ou um NAT ou firewall esquece a conexão em silêncio, nada é enviado, e o seu socket continua ESTABLISHED. Isso é uma conexão semiaberta. Quanto tempo você espera depende do que faz:

A conclusão é que você precisa definir os seus próprios timeouts e não depender dos padrões:

Uma armadilha relacionada fica no meio da rede: balanceadores de carga, gateways NAT e firewalls descartam conexões ociosas em silêncio depois de um tempo que costuma ficar entre um e alguns minutos. O próximo pacote em uma conexão assim é respondido com um reset, ou com nada. Defina o período do keepalive ou do heartbeat abaixo do menor timeout de inatividade no caminho, e deixe os pools de conexões descartarem conexões que ficaram ociosas por mais tempo que isso.

10. Lendo os sintomas

SintomaCausa provávelOnde olhar
Latência presa em cerca de 40 ms, CPU ociosawrite-write-read com Nagle e ACK atrasadoduas escritas por mensagem; defina TCP_NODELAY ou una as escritas
Latência ocasional de 1, 3 ou 7 s; conexões recusadas ou com timeoutfila de accept cheia, handshakes descartadoscontadores de listen overflow em nstat ou netstat -s; backlog; laço de accept bloqueado
"Cannot assign requested address", milhares de TIME_WAITmuitas conexões curtas de uma origem para um destinoss -s; reutilização e pool de conexões
Número crescente de sockets em CLOSE_WAITo programa não fecha os socketsclose ausente em um caminho de erro; contagem de descritores de arquivo
Travamentos de muitos minutos após uma falha do par ou da redesem timeouts; conexão semiabertaprazos, keepalive, heartbeats
Resets ou travamentos em conexões ociosas por cerca de um minutotimeout de inatividade de um intermediárioperíodo de keepalive abaixo do timeout de inatividade; expiração no pool
Rápido na mesma máquina, lento entre regiõeslimites de janela e de ida e volta; nova conexão por requisiçãoproduto banda-atraso; reutilização; buffers maiores

As ferramentas a usar: ss -tan (estados e comprimentos de fila por socket), ss -s (um resumo dos estados), nstat ou netstat -s (contadores de retransmissões e de overflow de escuta), tcpdump ou Wireshark (os pacotes reais: o intervalo de 40 ms e as retransmissões ficam visíveis de imediato) e, para HTTP, curl -w com variáveis de tempo para ver o tempo de cada fase (resolução de nome, conexão, TLS, primeiro byte).

11. Erros comuns

12. O que mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

O main.go abaixo (chamado tcpx nas medições) contém os quatro experimentos, um por comando: go run . nagle, go run . setup, go run . backlog e go run . timewait 40000. Eles usam apenas a biblioteca padrão do Go e precisam de Linux (o programa lê /proc/net/tcp para contar os sockets por estado). A execução de esgotamento de portas foi feita duas vezes: uma com a configuração padrão e outra depois de escrever 0 em /proc/sys/net/ipv4/tcp_tw_reuse (isso exige root, e a configuração deve ser restaurada ao valor anterior depois).

main.go

// tcpx: small experiments on TCP behaviour over the loopback interface (Linux). Usage: go run . nagle|setup|timewait|backlog
package main

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"net"
	"os"
	"sort"
	"strings"
	"syscall"
	"time"
)

func must(err error) {
	if err != nil {
		panic(err)
	}
}

func pct(d []time.Duration, p float64) time.Duration {
	s := append([]time.Duration(nil), d...)
	sort.Slice(s, func(i, j int) bool { return s[i] < s[j] })
	return s[int(float64(len(s)-1)*p)]
}

// ---------- 1. Nagle's algorithm and delayed acknowledgements ----------

// A server that reads a 4-byte header and a 100-byte body, then answers with one byte.
func requestServer(ln net.Listener, noDelay bool) {
	for {
		c, err := ln.Accept()
		if err != nil {
			return
		}
		go func(c net.Conn) {
			defer c.Close()
			c.(*net.TCPConn).SetNoDelay(noDelay)
			buf := make([]byte, 104)
			for {
				if _, err := io.ReadFull(c, buf); err != nil {
					return
				}
				c.Write([]byte{1})
			}
		}(c)
	}
}

func nagleRun(noDelay, oneWrite bool, n int) (avg, p99 time.Duration) {
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	must(err)
	defer ln.Close()
	go requestServer(ln, noDelay)
	c, err := net.Dial("tcp", ln.Addr().String())
	must(err)
	defer c.Close()
	c.(*net.TCPConn).SetNoDelay(noDelay)
	hdr, body, both, one := make([]byte, 4), make([]byte, 100), make([]byte, 104), make([]byte, 1)
	var lat []time.Duration
	for i := 0; i < n; i++ {
		t := time.Now()
		if oneWrite {
			c.Write(both)
		} else {
			c.Write(hdr) // two small writes, then wait for the answer: the classic write-write-read
			c.Write(body)
		}
		io.ReadFull(c, one)
		lat = append(lat, time.Since(t))
	}
	var sum time.Duration
	for _, d := range lat {
		sum += d
	}
	return sum / time.Duration(len(lat)), pct(lat, 0.99)
}

func nagle() {
	fmt.Println("write(4 bytes), write(100 bytes), then wait for a 1-byte answer; 300 requests on one connection")
	for _, tc := range []struct {
		name            string
		noDelay, single bool
	}{
		{"Nagle on  (default socket), two writes", false, false},
		{"TCP_NODELAY,               two writes", true, false},
		{"Nagle on  (default socket), one write ", false, true},
	} {
		avg, p99 := nagleRun(tc.noDelay, tc.single, 300)
		fmt.Printf("  %-42s average %8.2f ms   99th percentile %8.2f ms\n", tc.name, float64(avg.Microseconds())/1000, float64(p99.Microseconds())/1000)
	}
}

// ---------- 2. What a new connection costs ----------

func echoServer(ln net.Listener) {
	for {
		c, err := ln.Accept()
		if err != nil {
			return
		}
		go func(c net.Conn) {
			defer c.Close()
			io.Copy(c, c)
		}(c)
	}
}

func setup() {
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	must(err)
	defer ln.Close()
	go echoServer(ln)
	addr := ln.Addr().String()
	one := []byte{1}
	rt := func(c net.Conn) { c.Write(one); io.ReadFull(c, make([]byte, 1)) }

	const n = 5000
	c, err := net.Dial("tcp", addr)
	must(err)
	t := time.Now()
	for i := 0; i < n; i++ {
		rt(c)
	}
	reuse := time.Since(t) / n
	c.Close()

	t = time.Now()
	for i := 0; i < n; i++ {
		c, err := net.Dial("tcp", addr)
		must(err)
		rt(c)
		c.Close()
	}
	fresh := time.Since(t) / n
	fmt.Printf("loopback, one request of 1 byte: reused connection %.1f us, new connection each time %.1f us (%.1fx)\n",
		float64(reuse.Nanoseconds())/1000, float64(fresh.Nanoseconds())/1000, float64(fresh)/float64(reuse))
	fmt.Println("(loopback has no distance, so this is the CPU and kernel cost only. On a real network every new connection also costs the round trips below.)")
	fmt.Println()
	fmt.Println("round trips before the first byte of a response, by round-trip time (RTT):")
	fmt.Printf("  %-8s %-26s %-30s %-30s\n", "RTT", "reused connection", "new TCP connection", "new TCP + TLS 1.3 (full)")
	for _, rtt := range []int{1, 10, 50, 100, 200} {
		fmt.Printf("  %-8s %-26s %-30s %-30s\n", fmt.Sprintf("%d ms", rtt), fmt.Sprintf("%d ms", rtt), fmt.Sprintf("%d ms", 2*rtt), fmt.Sprintf("%d ms", 3*rtt))
	}
	// slow start: how many round trips to send 100 KB, 1 MB, 10 MB from a cold connection with an initial window of 10 segments
	fmt.Println()
	fmt.Println("slow start: round trips to send a response over a new connection (initial window 10 segments of 1,460 bytes, doubling every round trip, no loss)")
	for _, size := range []int{15_000, 100_000, 1_000_000, 10_000_000} {
		w, sent, rounds := 10*1460, 0, 0
		for sent < size {
			sent += w
			w *= 2
			rounds++
		}
		fmt.Printf("  %10s bytes: %d round trips\n", commas(size), rounds)
	}
}

func commas(n int) string {
	s := fmt.Sprint(n)
	var out []string
	for len(s) > 3 {
		out = append([]string{s[len(s)-3:]}, out...)
		s = s[:len(s)-3]
	}
	return strings.Join(append([]string{s}, out...), ",")
}

// ---------- 3. TIME_WAIT ----------

func countStates() map[string]int {
	names := map[string]string{"01": "ESTABLISHED", "06": "TIME_WAIT", "08": "CLOSE_WAIT", "0A": "LISTEN"}
	out := map[string]int{}
	for _, f := range []string{"/proc/net/tcp", "/proc/net/tcp6"} {
		fh, err := os.Open(f)
		if err != nil {
			continue
		}
		sc := bufio.NewScanner(fh)
		sc.Scan()
		for sc.Scan() {
			fs := strings.Fields(sc.Text())
			if len(fs) > 3 {
				if n, ok := names[fs[3]]; ok {
					out[n]++
				}
			}
		}
		fh.Close()
	}
	return out
}

func timewait() {
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	must(err)
	defer ln.Close()
	go func() { // server: read to EOF, then close (so the CLIENT closes first and keeps the TIME_WAIT)
		for {
			c, err := ln.Accept()
			if err != nil {
				return
			}
			go func(c net.Conn) { io.Copy(io.Discard, c); c.Close() }(c)
		}
	}()
	addr := ln.Addr().String()
	before := countStates()["TIME_WAIT"]
	n := 20000
	if len(os.Args) > 2 {
		fmt.Sscan(os.Args[2], &n)
	}
	t := time.Now()
	failures := 0
	var firstErr error
	for i := 0; i < n; i++ {
		c, err := net.DialTimeout("tcp", addr, 2*time.Second)
		if err != nil {
			failures++
			if firstErr == nil {
				firstErr = err
			}
			continue
		}
		c.Close()
	}
	el := time.Since(t)
	st := countStates()
	fmt.Printf("%d short connections to one address, the client closing first, in %.1f s (%.0f per second)\n", n, el.Seconds(), float64(n)/el.Seconds())
	fmt.Printf("  sockets in TIME_WAIT: %d before, %d after (failed connects: %d)\n", before, st["TIME_WAIT"], failures)
	if firstErr != nil {
		fmt.Println("  first error:", firstErr)
	}
	lo, hi := portRange()
	fmt.Printf("  ephemeral port range %d-%d = %d ports; a port towards one destination is blocked for 60 s after a close, so the ceiling is about %d new connections per second per destination\n",
		lo, hi, hi-lo+1, (hi-lo+1)/60)
}

func portRange() (int, int) {
	b, _ := os.ReadFile("/proc/sys/net/ipv4/ip_local_port_range")
	var lo, hi int
	fmt.Sscan(string(b), &lo, &hi)
	return lo, hi
}

// ---------- 4. The accept backlog ----------

func backlog() {
	fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, 0)
	must(err)
	defer syscall.Close(fd)
	must(syscall.Bind(fd, &syscall.SockaddrInet4{Port: 0, Addr: [4]byte{127, 0, 0, 1}}))
	must(syscall.Listen(fd, 1)) // backlog of 1, and the program never calls accept
	sa, _ := syscall.Getsockname(fd)
	addr := fmt.Sprintf("127.0.0.1:%d", sa.(*syscall.SockaddrInet4).Port)
	fmt.Println("a server that listens with a backlog of 1 and does not call accept at first; clients connect one after the other; accept starts after 2.5 s")
	// The server starts accepting after 2.5 seconds, which empties the queue.
	go func() {
		time.Sleep(2500 * time.Millisecond)
		for {
			nfd, _, err := syscall.Accept(fd)
			if err != nil {
				return
			}
			syscall.Close(nfd)
		}
	}()
	var keep []net.Conn
	start := time.Now()
	for i := 1; i <= 4; i++ {
		t := time.Now()
		c, err := net.DialTimeout("tcp", addr, 10*time.Second)
		d := time.Since(t)
		if err != nil {
			var ne net.Error
			kind := "error"
			if errors.As(err, &ne) && ne.Timeout() {
				kind = "timed out"
			}
			fmt.Printf("  connection %d: %s after %.2f s\n", i, kind, d.Seconds())
			continue
		}
		keep = append(keep, c)
		fmt.Printf("  connection %d: asked at %.2f s, connected after %.3f s\n", i, t.Sub(start).Seconds(), d.Seconds())
	}
	for _, c := range keep {
		c.Close()
	}
}

func main() {
	if len(os.Args) < 2 {
		fmt.Println("usage: tcpx nagle|setup|timewait|backlog")
		return
	}
	switch os.Args[1] {
	case "nagle":
		nagle()
	case "setup":
		setup()
	case "timewait":
		timewait()
	case "backlog":
		backlog()
	}
}

Fontes

Pratique este tema: Networking & APIs

Mais guias