CodeGym /Cursos /JAVA 25 SELF /Tratamento de erros em IO assíncrono e cancelamento de op...

Tratamento de erros em IO assíncrono e cancelamento de operações

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

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.

1
Tarefa
JAVA 25 SELF, nível 56, lição 3
Bloqueado
Mudança de canal: cancelamento do download de vídeo 🎬
Mudança de canal: cancelamento do download de vídeo 🎬
1
Tarefa
JAVA 25 SELF, nível 56, lição 3
Bloqueado
Monitoramento de logs do sistema: verificação paralela e cancelamento de emergência 🚨
Monitoramento de logs do sistema: verificação paralela e cancelamento de emergência 🚨
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION