Асинхронное IO: AsynchronousFileChannel (NIO2)

1. Знакомство с асинхронным IO

Давайте сразу разберёмся с терминами. В классическом (синхронном) IO, когда вы вызываете метод чтения или записи, ваш поток выполнения (например, основной поток программы) останавливается и ждёт, пока операция завершится. Это похоже на то, как если бы вы позвонили другу и, пока он не возьмёт трубку, вы бы просто стояли и ждали, уставившись в телефон.

Асинхронный IO (AIO) — это когда вы поручаете операцию чтения/записи системе, а сами продолжаете работать дальше. Когда операция завершится — вам «позвонят» обратно (например, вызовут ваш callback-метод или вернут результат через Future).

Где это нужно?

• Серверные приложения: чтобы не тратить потоки впустую, пока диск «думает».
• Массовая обработка больших файлов: чтобы не блокировать основной поток.
• Приложения с UI: чтобы интерфейс не «зависал» во время чтения/записи.

Представьте, что вы заказали пиццу. В синхронном мире вы бы стояли у двери и ждали доставщика. В асинхронном — вы делаете свои дела, а когда пицца приедет, вам позвонят и скажут: «Пицца здесь!»

2. Обзор AsynchronousFileChannel

В Java асинхронный ввод/вывод реализован в пакете java.nio.channels начиная с 7-й версии. Главный герой — класс AsynchronousFileChannel.

Что он умеет?

• Асинхронно читать и записывать данные в файл.
• Работать с буферами (ByteBuffer).
• Использовать разные подходы для получения результата: через Future или через CompletionHandler.
• Позволяет явно указать пул потоков (ExecutorService) для обработки событий.

Основные методы

• read(ByteBuffer dst, long position): возвращает Future<Integer>.
• read(ByteBuffer dst, long position, A attachment, CompletionHandler<Integer, ? super A> handler).
• write(ByteBuffer src, long position): возвращает Future<Integer>.
• write(ByteBuffer src, long position, A attachment, CompletionHandler<Integer, ? super A> handler).
• static open(Path file, Set<OpenOption> options, ExecutorService executor, FileAttribute<?>... attrs) — открывает канал.

Варианты работы:

• Через Future: вы запускаете операцию и можете потом дождаться её завершения.
• Через CompletionHandler: вы передаёте «обработчик», который вызовется, когда операция завершится (или упадёт с ошибкой).

Пример открытия файла для асинхронного чтения/записи

import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;

AsynchronousFileChannel channel = AsynchronousFileChannel.open(
    Path.of("data.txt"),
    EnumSet.of(StandardOpenOption.READ, StandardOpenOption.WRITE)
);

Можно также явно указать пул потоков для обработки событий:

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

ExecutorService executor = Executors.newFixedThreadPool(4);

AsynchronousFileChannel channel = AsynchronousFileChannel.open(
    Path.of("data.txt"),
    EnumSet.of(StandardOpenOption.READ, StandardOpenOption.WRITE),
    executor
);

Интересный факт:
Если не указать ExecutorService, Java создаст собственный внутренний пул потоков, который будет обслуживать IO-события. Для простых задач этого достаточно, но для серверных приложений лучше управлять пулом самостоятельно.

3. Потоки-исполнители (ExecutorService) и их роль

Когда вы работаете с асинхронным каналом, где-то за кулисами Java должна выполнить ваши callback-и или завершить Future. Делает она это не волшебством, а с помощью специальных рабочих потоков — executor service.

Если вы не передаёте свой пул потоков, Java просто создаёт внутренний — обычно один поток на каждый процессор. Удобно, но не всегда безопасно. Когда же вы хотите сами управлять тем, сколько потоков крутится, какие задачи важнее и как распределяется нагрузка, лучше создать свой ExecutorService и передать его в open.

В серверных приложениях это особенно важно. Без собственного пула потоков можно легко получить неожиданные всплески нагрузки — и вместо плавной работы сервер начнёт задыхаться.

Пример:

ExecutorService pool = Executors.newFixedThreadPool(8);

AsynchronousFileChannel channel = AsynchronousFileChannel.open(
    Path.of("huge.log"),
    EnumSet.of(StandardOpenOption.READ),
    pool
);

Влияние выбора пула:

• Много потоков — больше параллелизма, но и больше нагрузка на систему.
• Мало потоков — меньше одновременных операций, но меньше overhead.
• Если вы запускаете тысячи асинхронных операций, подумайте о балансе!

4. Практика: Асинхронное чтение файла

Синхронное чтение (для сравнения)

import java.nio.file.Files;
import java.nio.file.Path;

byte[] data = Files.readAllBytes(Path.of("input.txt"));
System.out.println("Прочитано байт: " + data.length);

Проблема здесь в том, что поток просто ждёт, пока весь файл не прочитается. Если файл большой или диск тормозит, программа тоже начинает «тормозить» — всё остальное в этот момент стоит на паузе.

Асинхронное чтение с AsynchronousFileChannel и Future

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

public class AsyncReadExample {
    public static void main(String[] args) throws Exception {
        Path path = Path.of("input.txt");
        try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024); // читаем по 1 КБ

            Future<Integer> result = channel.read(buffer, 0);

            // Можно делать что-то ещё параллельно!
            System.out.println("Чтение запущено...");

            // ... а потом дожидаемся результата
            int bytesRead = result.get(); // блокирует поток до завершения операции

            System.out.println("Прочитано байт: " + bytesRead);

            buffer.flip();
            // Преобразуем байты в строку (если это текст)
            byte[] data = new byte[bytesRead];
            buffer.get(data, 0, bytesRead);
            String text = new String(data);
            System.out.println("Содержимое: " + text);
        }
    }
}

• channel.read(buffer, 0) — запускает асинхронное чтение с позиции 0.
• Возвращает Future<Integer>, который можно использовать для ожидания результата.
• Пока операция не завершена, можно выполнять другие действия.
• result.get() блокирует поток, но только если результат ещё не готов.

Асинхронное чтение с CompletionHandler

(Подробнее разберём в следующей лекции, но для затравки...)

import java.nio.channels.AsynchronousFileChannel;
import java.nio.ByteBuffer;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.channels.CompletionHandler;

public class AsyncReadWithHandler {
    public static void main(String[] args) throws Exception {
        Path path = Path.of("input.txt");
        try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);

            channel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                @Override
                public void completed(Integer bytesRead, ByteBuffer buf) {
                    buf.flip();
                    byte[] data = new byte[bytesRead];
                    buf.get(data, 0, bytesRead);
                    String text = new String(data);
                    System.out.println("Асинхронно прочитано: " + text);
                }

                @Override
                public void failed(Throwable exc, ByteBuffer buf) {
                    System.err.println("Ошибка чтения: " + exc.getMessage());
                }
            });

            // Не даём программе завершиться сразу (иначе не успеет callback)
            Thread.sleep(100); // В реальных приложениях — лучше синхронизация через latch, future и т.п.
        }
    }
}

5. Полезные нюансы

Сравнение: Асинхронное vs Синхронное чтение

Схема работы асинхронного IO

sequenceDiagram
    participant Main as Ваш поток
    participant OS as Операционная система
    participant Disk as Диск

    Main->>OS: Запускает асинхронное чтение (read)
    OS->>Disk: Читает данные
    Main->>Main: Выполняет другие задачи
    OS-->>Main: Сообщает о завершении (Future/CompletionHandler)
    Main->>Main: Обрабатывает результат

6. Типичные ошибки при работе с AsynchronousFileChannel

Ошибка №1: забыли закрыть канал.
AsynchronousFileChannel — это ресурс, который нужно закрывать. Если забыть закрыть канал (channel.close() или try-with-resources), можно получить утечки дескрипторов и проблемы с доступом к файлам. Используйте try-with-resources всегда, когда возможно.

Ошибка №2: блокирующий get() в основном потоке.
Если вы используете Future и вызываете get() в главном потоке (например, в UI-приложении), вы теряете смысл асинхронного IO — поток всё равно будет ждать. Используйте CompletionHandler или отдельный поток для ожидания результата.

Ошибка №3: некорректная работа с ByteBuffer.
После записи в буфер не забывайте делать flip(), чтобы подготовить его к чтению. После чтения — clear() или compact(), если будете использовать его снова.

Ошибка №4: забыли обработать ошибки.
Асинхронные операции могут завершиться с ошибкой (например, файл не найден, нет доступа). Если не обработать исключения в CompletionHandler или не проверить Future на ошибку, программа «молча» не выполнит операцию.

Ошибка №5: неучтённый параллелизм.
Если вы запускаете несколько операций на одном канале одновременно, убедитесь, что ваш код потокобезопасен и не возникает гонок за буферы или позиции файла.