CodeGym /Cursos /JAVA 25 SELF /Processamento assíncrono de arquivos de texto

Processamento assíncrono de arquivos de texto

JAVA 25 SELF
Nível 56, Lição 2
Disponível

1. Leitura de arquivo por partes: ByteBuffer e codificação

Hoje em dia raramente lidamos com arquivos de texto pequenos. Geralmente são logs enormes de servidores, relatórios, arquivos CSV ou dumps de dados de gigabytes. Por isso é importante não apenas ler o arquivo, mas fazê-lo de forma eficiente e sem travar o aplicativo.

A abordagem assíncrona ajuda exatamente nisso: ela não bloqueia a thread principal — seja a interface ou a lógica do servidor —, permite ler e gravar grandes volumes de dados em paralelo e torna o aplicativo escalável quando é preciso trabalhar com vários arquivos ao mesmo tempo.

O ponto principal: E/S assíncrona não acelera o disco em si — não há milagres. Ela apenas permite que seu programa não fique ocioso enquanto o disco executa a operação e faça outras tarefas nesse meio tempo.

Como a leitura assíncrona funciona?

O canal assíncrono (AsynchronousFileChannel) não lê linhas, mas blocos de bytes para um objeto ByteBuffer. É como se você carregasse caixas com letras, e não palavras individuais. Após a leitura, você precisa transformar esses bytes em strings — levando em conta a codificação!

Exemplo: leitura assíncrona do arquivo em blocos

Vamos escrever um exemplo simples de leitura assíncrona do arquivo em blocos de 4096 bytes e exibir o conteúdo no console.

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.Future;
import java.nio.charset.StandardCharsets;
import java.io.IOException;

public class AsyncTextReadExample {
    public static void main(String[] args) throws Exception {
        Path path = Path.of("bigfile.txt");
        try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(4096);
            long position = 0;
            int bytesRead;
            Future<Integer> future = channel.read(buffer, position);

            while ((bytesRead = future.get()) > 0) {
                buffer.flip();
                // Convertemos os bytes em string (UTF-8)
                String chunk = StandardCharsets.UTF_8.decode(buffer).toString();
                System.out.print(chunk);
                buffer.clear();
                position += bytesRead;
                future = channel.read(buffer, position);
            }
        }
    }
}

Pontos importantes:

  • Lemos o arquivo por partes (por buffer), não inteiro.
  • Após a leitura, os bytes são decodificados em string com Charset.
  • Após o processamento, liberamos o buffer: buffer.clear(), se todos os bytes já foram decodificados, ou buffer.compact(), se no fim do bloco podem ter sobrado bytes de um caractere incompleto.
  • Este exemplo falha com caracteres multibyte: Charset.decode() substitui por “�” o caractere “partido” no limite entre os blocos. Por que isso acontece e como corrigir — veja abaixo.

Por que apenas decodificar bytes não basta?

O problema é que um caractere pode “quebrar” entre dois blocos, especialmente quando se usa uma codificação multibyte (por exemplo, "UTF-8"). Se o último byte no buffer for metade de um caractere, o próximo bloco começará com o “resto” do caractere. Sem tratamento especial você terá texto embaralhado ou até um erro de decodificação.

2. Converter bytes em strings: tratamento de quebras

Problema das quebras de linha

Suponha que você tenha a string "Ola\nMundo\n", e o buffer terminou em "Ol", e "a\nMundo\n" caiu no próximo bloco. Se apenas concatenar as strings, você pode perder caracteres ou obter uma string incorreta.

Solução: usar CharsetDecoder

O Java fornece a classe CharsetDecoder, que sabe tratar corretamente esses casos. Ele próprio não guarda os bytes: se no fim do buffer estiver o início de um caractere multibyte, decode() deixará esses bytes no ByteBuffer — a posição do buffer vai parar logo antes deles. Sua tarefa é não perdê-los: depois da decodificação, chame buffer.compact(), e não buffer.clear(). O método compact() move os bytes não decodificados para o início do buffer, e a próxima leitura grava os novos logo depois deles.

Exemplo de uso do CharsetDecoder

import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.CharBuffer;
import java.nio.ByteBuffer;

CharsetDecoder decoder = Charset.forName("UTF-8").newDecoder();
ByteBuffer buffer = ... // seus bytes
CharBuffer charBuffer = CharBuffer.allocate(buffer.capacity());
decoder.decode(buffer, charBuffer, false);
// Agora charBuffer contém caracteres decodificados corretamente

Não é preciso guardar o “resto” dos bytes à parte — o próprio ByteBuffer o guarda depois de compact(). Quando a entrada terminar, chame decode uma última vez com endOfInput = true e, em seguida, decoder.flush(charBuffer) — é o que exige o contrato de CharsetDecoder. E verifique o resultado de decode: com bytes inválidos, ele retorna um erro em vez de avançar.

3. Gravação assíncrona de arquivos de texto

Ler é apenas metade do trabalho. A gravação também é feita em blocos de bytes, que primeiro precisam ser obtidos a partir das strings (codificação).

Exemplo: gravação assíncrona de uma string em arquivo

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.Future;
import java.nio.charset.StandardCharsets;

public class AsyncTextWriteExample {
    public static void main(String[] args) throws Exception {
        Path path = Path.of("output.txt");
        String text = "Olá, mundo!\n";
        ByteBuffer buffer = ByteBuffer.wrap(text.getBytes(StandardCharsets.UTF_8));
        try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
            Future<Integer> future = channel.write(buffer, 0);
            // Para demonstração, vamos aguardar a conclusão (normalmente não é necessário!)
            future.get();
            System.out.println("Dados gravados de forma assíncrona.");
        }
    }
}

Comentário: Em cenários realmente assíncronos, evite chamar future.get() na thread principal — isso transforma o código assíncrono em síncrono. É melhor usar CompletionHandler (veja a aula anterior).

4. Prática: leitura assíncrona de um arquivo de texto grande e contagem de linhas

Vamos implementar uma tarefa prática: ler assíncronamente um arquivo de texto grande e contar a quantidade de linhas ("\n"). Resultado: imprimir a quantidade de linhas no console.

Exemplo usando CompletionHandler

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.StandardCharsets;
import java.nio.CharBuffer;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicLong;

public class AsyncLineCounter {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("bigfile.txt");
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);

        ByteBuffer buffer = ByteBuffer.allocate(4096);
        AtomicLong position = new AtomicLong(0);
        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
        StringBuilder leftover = new StringBuilder();
        AtomicLong lines = new AtomicLong(0);

        channel.read(buffer, position.get(), null, new CompletionHandler<Integer, Object>() {
            @Override
            public void completed(Integer result, Object attachment) {
                boolean endOfInput = (result == -1); // -1: arquivo lido até o fim
                buffer.flip();
                // +1 — margem para um caractere que o decodificador pode ter “segurado” até o fim da entrada
                CharBuffer charBuffer = CharBuffer.allocate(buffer.remaining() + 1);
                CoderResult cr = decoder.decode(buffer, charBuffer, endOfInput);
                if (!cr.isError() && endOfInput) {
                    cr = decoder.flush(charBuffer); // após o último decode(..., true)
                }
                if (cr.isError()) {
                    // Bytes inválidos: sem esta verificação, o ciclo “compact → read → decode” não avança
                    try { cr.throwException(); } catch (CharacterCodingException e) { failed(e, attachment); }
                    return;
                }
                charBuffer.flip();
                String chunk = leftover.toString() + charBuffer.toString();
                leftover.setLength(0);

                // Contamos as linhas
                int last = 0;
                int idx;
                while ((idx = chunk.indexOf('\n', last)) != -1) {
                    lines.incrementAndGet();
                    last = idx + 1;
                }
                // Resto (parte da linha após o último \n)
                if (last < chunk.length()) {
                    leftover.append(chunk.substring(last));
                }

                if (endOfInput) {
                    // A última linha sem '\n' também conta como linha
                    if (leftover.length() > 0) lines.incrementAndGet();
                    System.out.println("Linhas no arquivo: " + lines.get());
                    try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
                    return;
                }
                // Os bytes não decodificados (o início de um caractere “partido”) ficaram em buffer.
                // compact() os move para o início do buffer, e a próxima leitura grava os bytes logo depois deles.
                buffer.compact();
                position.addAndGet(result);
                channel.read(buffer, position.get(), null, this);
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                System.err.println("Erro de leitura: " + exc.getMessage());
                try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
            }
        });

        // Para que o programa não finalize antes da hora (apenas para o exemplo!)
        try { Thread.sleep(2000); } catch (InterruptedException e) {}
    }
}
  • Usamos CompletionHandler para código realmente assíncrono.
  • Após cada leitura, o buffer é decodificado com CharsetDecoder.
  • O restante da linha que não termina com "\n" é levado para o próximo bloco.
  • Os bytes não decodificados no fim do bloco ficam em buffer, e compact() os preserva para a próxima leitura. Já leftover é o final da linha (já em caracteres): serve só para contar as linhas.
  • Quando read retorna -1, fazemos o último decode(..., true) e o flush(). Se os bytes forem inválidos, decode retorna um erro — nós o passamos para failed(), senão o ciclo de leitura ficaria girando sem fim.
  • Ao final do arquivo, se algo restar em leftover, isso também conta como uma linha.
  • Para simplificar, o exemplo “dorme” por 2000 ms para a operação assíncrona terminar (em aplicativos reais isso não é necessário — normalmente há um loop principal ou UI).

5. Gravação assíncrona do resultado em arquivo

Suponha que queiramos gravar o resultado (por exemplo, a quantidade de linhas) em um novo arquivo — também de forma assíncrona.

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.charset.StandardCharsets;
import java.io.IOException;

public class AsyncWriteResult {
    public static void main(String[] args) throws IOException {
        String result = "Linhas no arquivo: 12345\n";
        ByteBuffer buffer = ByteBuffer.wrap(result.getBytes(StandardCharsets.UTF_8));
        Path path = Path.of("result.txt");

        AsynchronousFileChannel channel = AsynchronousFileChannel.open(
            path, StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);

        channel.write(buffer, 0, null, new CompletionHandler<Integer, Object>() {
            @Override
            public void completed(Integer written, Object attachment) {
                System.out.println("Resultado gravado de forma assíncrona!");
                try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                System.err.println("Erro de gravação: " + exc.getMessage());
                try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
            }
        });

        try { Thread.sleep(500); } catch (InterruptedException e) {}
    }
}

6. Dicas para tratar dados parciais e codificações

Linhas parciais entre blocos

Se um caractere estiver dividido entre dois blocos, não tente “colar” os bytes manualmente! CharsetDecoder vai parar antes do caractere incompleto, e buffer.compact() guardará os bytes dele até a próxima leitura.

Trabalhando com diferentes codificações

"UTF-8" é o padrão para aplicativos modernos, mas se o arquivo estiver em outra codificação (por exemplo, "Windows-1251" ou "UTF-16"), use o Charset correspondente:

import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;

Charset charset = Charset.forName("Windows-1251");
CharsetDecoder decoder = charset.newDecoder();

Uso de CharsetDecoder e CharsetEncoder

Ao ler ou gravar dados por partes, é importante trabalhar corretamente com a codificação. Um caractere pode “se partir” entre dois blocos e, sem tratamento adicional, vira uma bagunça de bytes.

Para evitar isso, use CharsetDecoder e CharsetEncoder.

Na leitura, chama-se decode(ByteBuffer, CharBuffer, endOfInput), e na gravação — encode(CharBuffer, ByteBuffer, endOfInput).

O decodificador para antes de um caractere incompleto e deixa os bytes dele no buffer de entrada. Só é possível montar o caractere se você preservar esses bytes (compact()) e passá-los para a próxima chamada de decode.

7. Erros comuns no processamento assíncrono de arquivos de texto

Erro nº 1: Perder os bytes não decodificados entre os blocos. Se você chamar buffer.clear() depois de decode, o início de um caractere multibyte “partido” se perde: o bloco seguinte começará no meio do caractere, e o decodificador retornará um erro ou texto embaralhado. Chame buffer.compact().

Erro nº 2: Uso incorreto do buffer. Se esquecer de chamar buffer.clear() ou buffer.compact() após o processamento, a próxima leitura não funcionará ou os dados ficarão incorretos.

Erro nº 3: Usar codificação inadequada. Se os bytes forem decodificados com um Charset diferente do usado na gravação do arquivo, podem surgir textos ilegíveis ou até erros.

Erro nº 4: Bloquear a thread principal. Se você chama future.get() ou Thread.sleep() na thread de UI, perde o propósito da assincronicidade. Use CompletionHandler e abordagens reativas.

Erro nº 5: Canal não fechado após a conclusão. Sempre feche o canal (channel.close()) após o término de todas as operações, mesmo se ocorreu um erro.

1
Tarefa
JAVA 25 SELF, nível 56, lição 2
Bloqueado
Secretário-veloz: contagem assíncrona de linhas em um relatório gigante 📊
Secretário-veloz: contagem assíncrona de linhas em um relatório gigante 📊
1
Tarefa
JAVA 25 SELF, nível 56, lição 2
Bloqueado
Fábrica de dados automatizada: leitura, processamento e gravação assíncrona 🤖
Fábrica de dados automatizada: leitura, processamento e gravação assíncrona 🤖
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION