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.
GO TO FULL VERSION