1. Tratamento de erros em operações assíncronas
No código síncrono é simples: se o arquivo não for encontrado ou não houver acesso, você captura a exceção imediatamente em try-catch. No código assíncrono, especialmente quando você usa callbacks (CompletionHandler), o erro pode ocorrer depois que o seu método já terminou — em algum lugar nas entranhas do pool de threads. Se ele não for tratado corretamente, o programa pode se comportar de forma imprevisível: desde a perda “silenciosa” de dados até a queda de todo o aplicativo.
Como os erros são propagados em CompletionHandler?
Na interface CompletionHandler<V, A> há dois métodos:
- completed(V result, A attachment) — é chamado quando a operação é bem-sucedida.
- failed(Throwable exc, A attachment) — é chamado quando ocorre um erro.
Exemplo de uso:
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.*;
import java.util.concurrent.Future;
import java.io.IOException;
public class AsyncErrorDemo {
public static void main(String[] args) throws Exception {
Path path = Paths.get("nonexistent.txt");
ByteBuffer buffer = ByteBuffer.allocate(1024);
try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
channel.read(buffer, 0, buffer, new java.nio.channels.CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
System.out.println("Lido com sucesso " + result + " bytes");
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
System.out.println("Erro de leitura do arquivo: " + exc.getMessage());
// É possível registrar em log, notificar o usuário, propagar o erro adiante
}
});
} catch (IOException ex) {
System.out.println("Erro ao abrir o arquivo: " + ex.getMessage());
}
// Daremos tempo para a operação assíncrona terminar (em aplicativos reais, use CountDownLatch ou outros mecanismos)
Thread.sleep(500);
}
}
O que está acontecendo aqui?
- Se o arquivo não existir, o método failed será chamado com a exceção correspondente (NoSuchFileException).
- Se a operação for concluída com sucesso — completed será acionado.
Exemplos de erros típicos
- Arquivo não encontrado: NoSuchFileException
- Sem acesso: AccessDeniedException
- Erro de leitura/gravação: várias subclasses de IOException
- Problemas com o buffer: BufferOverflowException, BufferUnderflowException
Registro de logs e informação ao usuário
Um erro em um callback assíncrono não é motivo para pânico, mas também não é motivo para fingir que nada aconteceu. Uma boa prática é registrar o erro em log (por exemplo, via Logger) e, se isso for importante para o usuário, mostrar uma mensagem ou invocar um handler na UI.
Exemplo de registro de logs:
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
System.err.println("Erro de operação assíncrona: " + exc);
exc.printStackTrace();
}
No código de produção, use loggers de verdade (por exemplo, java.util.logging ou Log4j), e não System.err.
2. Cancelamento de operações assíncronas
Quando pode ser necessário cancelar uma operação?
Às vezes é preciso interromper uma tarefa assíncrona no meio da execução. Por exemplo, o usuário desistiu e clicou em “Cancelar” durante o download de um arquivo. Ou a janela do programa foi fechada e a operação deixou de fazer sentido. E pode acontecer que, ao encerrar o aplicativo, seja preciso liberar os recursos com cuidado.
Para esses casos, o I/O assíncrono no Java suporta cancelamento via a interface Future. Com ela, você pode interromper uma tarefa em execução a qualquer momento e não desperdiçar recursos.
Como cancelar uma operação com Future?
Os métodos read ou write em AsynchronousFileChannel retornam um objeto Future<Integer>. Esse objeto possui o método cancel(boolean mayInterruptIfRunning).
Exemplo: cancelando uma leitura assíncrona
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.*;
import java.util.concurrent.Future;
import java.io.IOException;
public class AsyncCancelDemo {
public static void main(String[] args) throws Exception {
Path path = Paths.get("bigfile.txt");
ByteBuffer buffer = ByteBuffer.allocate(1024);
try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
Future<Integer> future = channel.read(buffer, 0);
// Vamos esperar um pouco e então cancelar a operação
Thread.sleep(100);
boolean cancelled = future.cancel(true);
if (cancelled) {
System.out.println("A operação de leitura foi cancelada!");
} else {
System.out.println("Não foi possível cancelar a operação (talvez ela já tenha sido concluída)");
}
}
}
}
Pontos importantes:
- O cancelamento funciona apenas para operações que ainda não foram concluídas.
- Se a operação já terminou — não será possível cancelá-la.
- Após o cancelamento, ao tentar chamar get() nesse Future, será lançada a exceção CancellationException.
Quando não é mais possível cancelar a operação?
Se a tarefa já tiver sido concluída — com sucesso ou com erro — não é mais possível pará-la; é tarde demais.
Além disso, nem todas as implementações realmente conseguem interromper operações no nível do sistema operacional. Por exemplo, ao trabalhar com alguns sistemas de arquivos, o “cancelamento” será apenas simbólico: a operação continuará executando, mas você simplesmente ignorará o resultado.
3. Prática: tratamento de erros e cancelamento
Exemplo 1: tratamento de erro ao ler um arquivo inexistente
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.*;
import java.io.IOException;
public class AsyncErrorExample {
public static void main(String[] args) throws Exception {
Path path = Paths.get("no_such_file.txt");
ByteBuffer buffer = ByteBuffer.allocate(1024);
try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
channel.read(buffer, 0, buffer, new java.nio.channels.CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
System.out.println("A operação foi concluída com sucesso");
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
System.out.println("Erro ao ler o arquivo: " + exc.getClass().getSimpleName() + " - " + exc.getMessage());
}
});
} catch (IOException ex) {
System.out.println("Erro ao abrir o arquivo: " + ex.getMessage());
}
Thread.sleep(500);
}
}
O que veremos no console?
Erro ao abrir o arquivo: no_such_file.txt
ou, se o erro ocorrer durante a leitura, e não na abertura:
Erro ao ler o arquivo: NoSuchFileException - no_such_file.txt
Exemplo 2: cancelamento de operação demorada e finalização correta
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.*;
import java.util.concurrent.Future;
import java.io.IOException;
public class AsyncCancelExample {
public static void main(String[] args) throws Exception {
Path path = Paths.get("bigfile.txt");
ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024 * 10); // 10 MB
try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
Future<Integer> future = channel.read(buffer, 0);
// Após 50 ms, cancelamos a operação (para experimentar)
Thread.sleep(50);
boolean cancelled = future.cancel(true);
if (cancelled) {
System.out.println("A operação de leitura foi cancelada!");
} else {
System.out.println("Não foi possível cancelar a operação (provavelmente ela já foi concluída)");
}
try {
// Vamos tentar obter o resultado (lançará CancellationException)
future.get();
} catch (java.util.concurrent.CancellationException ex) {
System.out.println("Pegamos CancellationException: a operação foi realmente cancelada.");
}
}
}
}
4. Boas práticas: como fazer do jeito certo
Libere recursos mesmo em caso de erro
Use try-with-resources para fechar os canais automaticamente:
try (AsynchronousFileChannel channel = /* open channel */ null) {
// ...
}
Se você usar CompletionHandler, não se esqueça de fechar o canal ao finalizar todas as operações. Isso é especialmente importante se você fizer várias operações assíncronas em sequência.
Não bloqueie a UI/o thread principal
As operações assíncronas existem para não bloquear o thread principal. Não chame future.get() na thread de UI — caso contrário, a proposta da assincronicidade se perde.
Registre todos os erros
Em CompletionHandler, sempre implemente o método failed e registre (ou propague) todas as exceções.
Verifique a conclusão de todas as operações antes de encerrar o programa
Se o programa terminar antes que a operação seja concluída, o resultado pode ser perdido. Para demonstrações em console às vezes é preciso fazer Thread.sleep(500), mas em aplicativos reais use CountDownLatch, CompletableFuture ou outros mecanismos de sincronização.
Não se esqueça do cancelamento
Se a operação não for mais necessária (por exemplo, o usuário fechou a janela), cancele-a via Future.cancel. Isso economiza recursos e melhora a responsividade do aplicativo.
5. Erros típicos no tratamento de erros e cancelamento em async IO
Erro nº 1: Ignorar o método failed em CompletionHandler.
Se você não implementar o tratamento de erros, seu aplicativo pode se comportar de forma imprevisível: os erros “se perderão” e o usuário ficará sem saber por que nada acontece.
Erro nº 2: Não fechar o canal após concluir as operações.
Esqueceu de fechar AsynchronousFileChannel — haverá vazamento de recursos e, possivelmente, bloqueio do arquivo no SO.
Erro nº 3: Aguardar o resultado de uma operação assíncrona na thread principal.
Chamou future.get() na thread de UI — a interface “travou” e toda a assincronicidade foi por água abaixo.
Erro nº 4: Tentar cancelar uma operação já concluída.
Chamou cancel() tarde demais — a operação já foi concluída, o cancelamento não funcionará. Isso não é crítico, mas pode confundir na depuração.
Erro nº 5: Não verificar o resultado do cancelamento.
Chamou cancel(), mas não verificou o valor retornado e não tratou CancellationException ao chamar get() — o programa pode cair ou se comportar de maneira estranha.
Erro nº 6: Não liberar recursos em caso de erro ou cancelamento.
Se o canal não for fechado após um erro ou cancelamento, podem ocorrer vazamentos ou bloqueios de arquivos.
GO TO FULL VERSION