Introdução ao Netty

Conceito e Arquitetura

O Netty é um framework de rede baseado em Java, originalmente mantido pela JBOSS e agora um projeto independente no GitHub. Ele utiliza uma arquitetura assíncrona e orientada a eventos para facilitar o desenvolvimento de servidores e clientes de rede de alto desempenho e escalabilidade.

Basicamente, o Netty abstrai as complexidades da programação de rede (como a API NIO nativa do Java) e fornece uma estrutura robusta para lidar com protocolos TCP e UDP. É especialmente eficaz em cenários de alta concorrência e transferência massiva de dados.

Casos de Uso Comuns

• Sistemas Distribuídos: Frameworks de RPC (como o Apache Dubbo) utilizam o Netty como base para comunicação entre nós de forma assíncrona.
• Indústria de Jogos: Devido ao suporte a protocolos personalizados e baixa latência, é amplamente usado em servidores de jogos multiplayer.
• Big Data: Ferramentas como o Apache Hadoop utliizam o Netty para serialização e transferência eficiente de dados entre clusters.

O Modelo de I/O do Linux

Conceitos Estruturais

Espaço do Usuário vs. Espaço do Kernel

Para garantir a segurança do sistema, os sistemas operacionais modernos dividem a memória virtual em duas áreas:

• Espaço do Kernel: Onde reside o núcleo do sistema operacional. Possui acesso total ao hardware e à memória protegida.
• Espaço do Usuário: Onde as aplicações comuns são executadas. Elas não podem acessar o hardware diretamente, dependendo de syscalls (chamadas de sistema) para interagir com o kernel.

Modo Usuário e Modo Kernel

Quando um processo está executando lógica interna, ele está em Modo Usuário. Ao solicitar uma leitura de disco ou envio de pacotes via rede, ocorre uma mudança de contexto para o Modo Kernel. Essa transição é custosa em termos de processamento.

File Descriptors (FD)

No Linux, quase tudo é tratado como um arquivo. Um File Descriptor é um número inteiro que aponta para uma estrutura no kernel representando um arquivo aberto, um socket ou um dispositivo. Operações de rede envolvem a leitura e escrita em socketfd.

Transferência de Dados e DMA

Em operações de I/O padrão, os dados passam do dispositivo para o buffer do kernel e depois para o buffer da aplicação. O DMA (Direct Memory Access) permite que o hardware transfira dados diretamente para a memória sem sobrecarregar a CPU.

Modelos de I/O na Prática

I/O Bloqueante (BIO)

Neste modelo, quando uma aplicação solicita uma leitura, ela fica "congelada" até que os dados cheguem da rede e sejam copiados para o seu espaço de memória. É simples de programar, mas escala mal em sistemas com milhares de conexões simultâneas.

I/O Não-Bloqueante (NIO)

A aplicação solicita os dados e o kernel retorna imediatamente. Se os dados não estiverem prontos, retorna um erro (como EAGAIN). A aplicação deve realizar uma consulta constante (polling) para verificar a disponibilidade dos dados.

Multiplexação de I/O

Utiliza chamadas como select, poll ou epoll. Um único thread monitora múltiplos canais de comunicação (sockets). Quando um dos canais está pronto para leitura ou escrita, o sistema notifica a aplicação.

I/O Assíncrono (AIO)

A aplicação inicia a operação e continua sua execução. O kernel cuida de toda a transferência (espera pelos dados e cópia para o buffer do usuário) e notifica a aplicação apenas quando o processo está concluído.

Implementação com Java NIO

Componentes Principais

• Channels: Representam a conexão aberta com uma entidade (arquivo, socket). Diferente dos Streams, são bidirecionais.
• Buffers: Contentores de dados que interagem com os Channels.
• Selectors: Permitem que um único thread gerencie múltiplos canais.

Refatorando o I/O Bloqueante (Exemplo BIO)

Abaixo, um exemplo de um servidor simples usando o modelo tradicional bloqueante:

public class ServidorLegado {
    public static void main(String[] args) throws IOException {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        ServerSocket server = new ServerSocket(9090);
        
        while (true) {
            final Socket cliente = server.accept(); // Bloqueia aqui
            pool.execute(() -> processar(cliente));
        }
    }

    private static void processar(Socket cliente) {
        byte[] buffer = new byte[1024];
        try (InputStream in = cliente.getInputStream()) {
            int total;
            while ((total = in.read(buffer)) != -1) {
                System.out.println("Recebido: " + new String(buffer, 0, total));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explorando Buffers no NIO

Um Buffer no NIO é essencialmente um bloco de memória. Ele possui três propriedades fundamentais:

1. Capacity: Tamanho total do buffer.
2. Position: Índice atual de leitura/escrita.
3. Limit: Ponto que não deve ser ultrapassado na leitura/escrita.

Exemplo de Manipulação de Buffer

IntBuffer intBuffer = IntBuffer.allocate(5);
for (int i = 0; i < intBuffer.capacity(); i++) {
    intBuffer.put(i * 10);
}

// Inverte o buffer para modo de leitura
intBuffer.flip();

while (intBuffer.hasRemaining()) {
    System.out.println(intBuffer.get());
}

Trabalhando com Channels

Escrita em Arquivos com FileChannel

public class GravadorNio {
    public static void main(String[] args) throws IOException {
        String texto = "Conteúdo de teste NIO";
        try (FileOutputStream fos = new FileOutputStream("saida.txt")) {
            FileChannel canal = fos.getChannel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put(texto.getBytes());
            buffer.flip();
            canal.write(buffer);
        }
    }
}

Transferência Direta entre Canais

O NIO permite transferir dados entre canais sem passar pelo buffer da aplicação no Modo Usuário, otimizando a performance (Zero Copy).

try (FileInputStream fis = new FileInputStream("origem.dat");
     FileOutputStream fos = new FileOutputStream("destino.dat")) {
    FileChannel canalOrigem = fis.getChannel();
    FileChannel canalDestino = fos.getChannel();
    canalDestino.transferFrom(canalOrigem, 0, canalOrigem.size());
}

O Poder do Selector

O Selector é o coração do I/O não-bloqueante no Java. Ele permite que um thread monitore vários canais registrados e reaja a eventos como conexões aceitas (OP_ACCEPT) ou dados disponíveis para leitura (OP_READ).

Selector seletor = Selector.open();
servidorChannel.configureBlocking(false);
servidorChannel.register(seletor, SelectionKey.OP_ACCEPT);

while (true) {
    if (seletor.select(2000) == 0) continue;
    
    Set<SelectionKey> chaves = seletor.selectedKeys();
    Iterator<SelectionKey> it = chaves.iterator();
    
    while (it.hasNext()) {
        SelectionKey chave = it.next();
        if (chave.isAcceptable()) {
            // Lógica para aceitar conexão
        }
        if (chave.isReadable()) {
            // Lógica para ler dados
        }
        it.remove();
    }
}

Considerações sobre Memory Management

O Java NIO oferece o MappedByteBuffer, que mapeia um arquivo diretamente na memória fora da Heap do Java. Isso reduz a necessidade de cópias entre o kernel e o espaço do usuário, sendo extremamente útil para manipular arquivos grandes com baixa latência.