1. Introdução ao Contexto do Projeto

Com a popularização da arquitetura de microserviços e aplicações web de alta concorrência, a distribuição uniforme das solicitações dos clientes entre múltiplos servidores backend tornou-se um elemento crucial para garantir o desempenho e a disponibilidade do sistema. O algoritmo mais fundamental e comum de balanceamento de carga é o "Round Robin" (rotação): disrtibuir as solicitações sequencialmente para cada servidor na lista, retornando ao início ao chegar ao final.

• Simplicidade: A lógica do algoritmo de rotação é intuitiva e não depende de estados complexos.
• Zero configuração: Não é necessário atribuir pesos aos servidores ou monitorar a carga em tempo real para começar a operar.
• Aplicações gerais: Adequado para cenários onde as instâncias backend têm desempenho e especificações semelhantes.

Este projeto tem como objetivo implementar em Java um balanceador de carga simples de rotação, thread-safe, do zero, ajudando os desenvolvedores a entender profundamente os princípios fundamentais e servindo de base para futuras otimizações, como rotação ponderada e verificações de saúde.

2. Requisitos do Projeto

• Requisitos Funcionais

1. Suporte para adição e dinâmica exclusão de instâncias de servidor backend;
2. Distribuição sequencial de solicitações conforme a estratégia de "rotação";
3. Suporte para chamadas concorrentes em múltiplos threads, garantindo resultados corretos de agendamento.

• Requisitos Não Funcionais

1. Desempenho: Com número de nós ≤ 50 e threads concorrentes ≤ 2000, a latência de agendamento deve ser de microssegundos;
2. Segurança thread: Em cenários de alta concorrência, sem seleção duplicada ou omissão;
3. Extensibilidade: Futuro suporte a pesos, verificações de saúde, prioridades e outras funcionalidades;
4. Facilidade de uso: API simples com baixa curva de aprendizado;
5. Testabilidade: Incluir casos de teste unitário para validar a sequência de rotação.

3. Tecnologias Relacionadas

1. Fundamentos Java

• Coleção List: Para armazenar a lista de servidores, suportando operações de add, remove, get;
• Variáveis atômicas: AtomicInteger ou AtomicLong para registrar o índice atual, garantindo segurança em ambientes concorrentes;
• Mecanismos de lock: Em cenários complexos, pode-se usar ReentrantLock;
• Ferramentas de concorrência: Como JUnit + ExecutorService para simular testes de alta concorrência.

2. Princípio do Algoritmo de Rotação

• Percorrimento sequencial: Manter um índice global currentIndex, atualizando antes de cada agendamento com currentIndex = (currentIndex + 1) % size;
• Reutilização cíclica: Quando o índice atinge o final, automaticamente retorna ao início da lista.

3. Estratégias de Segurança Thread

• Abordagem sem lock: Usar AtomicInteger para incremento e módulo, evitando competição por locks;
• Abordagem com lock: Ao modificar a lista (adicionar/remover nós) durante o agendamento, usar bloqueios para garantir consistência do estado.

4. Métodos de Teste

• Usar JUnit para escrever testes multithread, validando que a sequência de saída dos nós em ambiente concorrente corresponde à ordem esperada de rotação.

4. Abordagem de Implementação

4.1 Modelo de Dados

• Definir class ServidorBackend para representar uma instância backend, contendo identificador único (como id, endereco, etc.);
• Manter List<ServidorBackend> como lista de nós disponíveis.

4.2 Lógica Central de Agendamento

1. Inicialização

• indiceAtual inicializado como -1;
• A lista de nós pode estar vazia; nesse caso, o agendamento deve retornar null ou lançar exceção.

2. Seleção por Rotação

• A cada chamada de selecionarServidor():
• Obter primeiro o tamanho da lista n;
• Usar operação atômica: int idx = (indiceAtomico.incrementAndGet() & Integer.MAX_VALUE) % n;
• Retornar nos.get(idx).

3. Segurança em Ambientes Concorrentes

• Adição/Remoção de nós: Usar bloco synchronized ou lock de escrita durante operações de escrita, garantindo exclusividade entre modificação e leitura;
• Cálculo de módulo: Implementar sem lock usando variáveis atômicas para alta taxa de processamento;
• Tratamento de limites: Após adição ou remoção dinâmica de nós, indiceAtomico pode ser maior que o novo tamanho da lista, com retorno automático através do cálculo de módulo.

4.3 Design da API

public class BalanceadorCargaRoundRobin {
    public void adicionarServidor(ServidorBackend servidor);
    public void removerServidor(String idServidor);
    public ServidorBackend selecionarServidor();
    public List<ServidorBackend> listarServidores();
}

• adicionarServidor, removerServidor: Modificar a lista sob proteção de lock de escrita;
• selecionarServidor: Leitura sem lock do tamanho da lista e seleção através de incremento atômico e módulo;
• listarServidores: Retorna um instantâneo dos nós ativos, para monitoramento ou depuração.

4.4 Reflexões para Expansão

• Recuperação automática do índice: Quando indiceAtomico atinge o limite crítico Integer.MAX_VALUE, pode ser reiniciado em períodos de baixa atividade;
• Falha rápida: Se a lista estiver vazia, pode lançar exceção diretamente ou fallback para um nó padrão;
• Monitoramento com logs: Registrar logs de seleção de nós durante o processo, facilitando análise posterior da distribuição de tráfego.

5. Implementação Completa do Código

// ==================== Arquivo: ServidorBackend.java ====================
package com.exemplo.balanceador;

/**
 * Representa um nó de servidor backend
 */
public class ServidorBackend {
    /** Identificador único do nó */
    private final String id;
    /** Endereço ou outras informações do nó */
    private final String endereco;

    public ServidorBackend(String id, String endereco) {
        this.id = id;
        this.endereco = endereco;
    }

    public String getId() {
        return id;
    }

    public String getEndereco() {
        return endereco;
    }

    @Override
    public String toString() {
        return "ServidorBackend{id='" + id + "', endereco='" + endereco + "'}";
    }
}

// ==================== Arquivo: BalanceadorCargaRoundRobin.java ====================
package com.exemplo.balanceador;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Implementação de balanceador de carga com algoritmo Round Robin
 */
public class BalanceadorCargaRoundRobin {

    /** Lista de servidores ativos */
    private final List<ServidorBackend> servidores = new ArrayList<>();
    /** Índice atômico auto-incrementável, garantindo segurança em ambientes concorrentes */
    private final AtomicLong indice = new AtomicLong(0);

    /**
     * Adiciona um novo servidor à lista
     * @param servidor Novo servidor a ser adicionado
     */
    public synchronized void adicionarServidor(ServidorBackend servidor) {
        servidores.add(servidor);
    }

    /**
     * Remove um servidor da lista pelo seu ID
     * @param idServidor ID do servidor a ser removido
     */
    public synchronized void removerServidor(String idServidor) {
        servidores.removeIf(s -> s.getId().equals(idServidor));
    }

    /**
     * Retorna um instantâneo da lista atual de todos os servidores
     * @return Instantâneo da lista de servidores
     */
    public synchronized List<ServidorBackend> listarServidores() {
        return new ArrayList<>(servidores);
    }

    /**
     * Executa uma seleção por rotação e retorna o servidor escolhido
     * @return ServidorBackend selecionado nesta chamada; se não houver servidores, retorna null
     */
    public ServidorBackend selecionarServidor() {
        List<ServidorBackend> instantaneo;
        synchronized (this) {
            if (servidores.isEmpty()) {
                return null;
            }
            instantaneo = new ArrayList<>(servidores);
        }
        // Incremento atômico e cálculo de módulo
        long atual = indice.getAndIncrement();
        int idx = (int) (Math.floorMod(atual, instantaneo.size()));
        return instantaneo.get(idx);
    }
}

// ==================== Arquivo: TesteBalanceador.java ====================
package com.exemplo.balanceador;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

/**
 * Testes unitários JUnit para validar a sequência de rotação
 */
public class TesteBalanceador {

    private BalanceadorCargaRoundRobin balanceador;

    @Before
    public void configurar() {
        balanceador = new BalanceadorCargaRoundRobin();
        balanceador.adicionarServidor(new ServidorBackend("A", "192.168.0.1"));
        balanceador.adicionarServidor(new ServidorBackend("B", "192.168.0.2"));
        balanceador.adicionarServidor(new ServidorBackend("C", "192.168.0.3"));
    }

    @Test
    public void testarSequencia() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            ServidorBackend servidor = balanceador.selecionarServidor();
            sb.append(servidor.getId());
        }
        // Ordem esperada: ABCABC
        Assert.assertEquals("ABCABC", sb.toString());
    }

    @Test
    public void testarConcorrencia() throws Exception {
        // Simula seleções concorrentes em múltiplas threads, garantindo ausência de exceções
        int threads = 50;
        int chamadasPorThread = 100;
        StringBuilder sb = new StringBuilder();
        java.util.concurrent.ExecutorService executor = java.util.concurrent.Executors.newFixedThreadPool(threads);
        java.util.concurrent.CountDownLatch latch = new java.util.concurrent.CountDownLatch(threads);
        for (int t = 0; t < threads; t++) {
            executor.submit(() -> {
                for (int i = 0; i < chamadasPorThread; i++) {
                    ServidorBackend servidor = balanceador.selecionarServidor();
                    synchronized (sb) {
                        sb.append(servidor.getId());
                    }
                }
                latch.countDown();
            });
        }
        latch.await();
        executor.shutdown();
        // Valida apenas se o total de chamadas está correto
        Assert.assertEquals(threads * chamadasPorThread, sb.length());
    }
}

6. Análise Detalhada do Código

• ServidorBackend.java
• ServidorBackend(String id, String endereco): Construtor que inicializa o ID único e o endereço do servidor.
• toString(): Formata as informações do servidor para facilitar a depuração durante saídas de log.
• BalanceadorCargaRoundRobin.java
• adicionarServidor(ServidorBackend) / removerServidor(String) / listarServidores(): Operações de CRUD na lista servidores protegidas por synchronized, garantindo segurança em ambientes concorrentes.
• selecionarServidor():

1. Cria um instantâneo da lista dentro de um bloco synchronized para evitar modificações concorrentes durante o cálculo;
2. Utiliza AtomicLong indice para incremento sem lock;
3. Calcula o índice correto usando Math.floorMod(atual, tamanho) para evitar valores negativos e garantir o retorno ao início;
4. Retorna o servidor correspondente do instantâneo.

• TesteBalanceador.java
• testarSequencia(): Valida que em chamadas single-thread, os servidores são distribuídos na ordem cíclica "A→B→C→A→B→C";
• testarConcorrencia(): Usa um pool de threads para simular cenários de alta concorrência, chamando repetidamente selecionarServidor(), validando principalmente a ausência de exceções e a contagem correta de chamadas.

7. Resumo do Projeto

Este projeto implementa em Java o algoritmo fundamental de balanceamento de carga Round Robin, com as seguintes características principais:

1. Simples e eficiente: Utiliza incremento atômico sem lock e operações de módulo para alcançar latências de agendamento em milissegundos ou microssegundos;
2. Seguro para threads: Separa modificação e leitura da lista, com operações de escrita protegidas por lock e leituras sem lock, usando apenas instantâneos para equilibrar segurança e desempenho;
3. Fácil expansão: Baseado nesta estrutura, pode-se integrar funcionalidades avançadas como pesos, verificações de saúde e eliminação de falhas;
4. Alta testabilidade: Inclui testes unitários que validam a correção da sequência em cenários sequenciais e concorrentes.

8. Perguntas Comuns e Soluções

**Q1: Por que criar um instantâneo antes do cálculo do módulo?**A: Para evitar que durante o processo de selecionarServidor(), outra thread execute simultaneamente adicionarServidor() ou removerServidor(), causando alterações na lista servidores e inconsistência entre o índice e o tamanho da lista.

**Q2: Por que usar AtomicLong em vez de AtomicInteger?**A: Em volumes extremamente altos de requisições, AtomicInteger atinge seu limite superior e retorna a valores negativos, exigindo tratamento adicional. AtomicLong tem um intervalo maior e, com floorMod, realiza o cálculo de módulo corretamente.

**Q3: Como lidar com a ausência de servidores?**A: A implementação atual retorna null, mas dependendo dos requisitos do negócio, pode-se lançar uma exceção personalizada ou retornar um servidor padrão.

**Q4: Quando o índice deve ser reiniciado?**A: Este exemplo não reinicia o indice proativamente. Em operações de longa duração com número extremamente alto de chamadas, pode-se monitorar o valor do indice e reiniciá-lo com indice.set(indice % tamanho) durante períodos de baixa atividade.

9. Direções de Expansão e Otimização de Desempenho

1. Lista de nós sem lock

• Usar CopyOnWriteArrayList ou coleções concorrentes com separação de leitura/escrita para reduzir o escopo do synchronized;

2. Suporte a rotação ponderada

• Estender este framework com pesos, ou diretamente integrar o algoritmo "Smooth Weighted Round Robin" mencionado anteriormente;

3. Integração de verificações de saúde

• Implementar sondagem periódica da disponibilidade das instâncias, com entrada e saída automáticas para melhorar a disponibilidade;

4. Monitoramento e alertas

• Integrar com Prometheus/Grafana para monitoramento em tempo real de contagens de acertos e latências de resposta por nó, com alertas em casos anormais;

5. Coordenação distribuída

• Sincronizar listas de nós entre múltiplos balanceadores de carga para garantir consistência;

6. Priorização e isolamento

• Suportar tráfego de diferentes prioridades ou isolamento de tipos diferentes de tráfego durante o agendamento.