Асинхронний I/O: AsynchronousFileChannel (NIO2)

1. Знайомство з асинхронним I/O

Давайте одразу розберемося з термінами. У класичному (синхронному) I/O, коли ви викликаєте метод читання або запису, ваш потік виконання (наприклад, основний потік програми) зупиняється й чекає, доки операція завершиться. Це схоже на те, ніби ви зателефонували другу і, доки він не візьме слухавку, ви просто стоїте й чекаєте, втупившись у телефон.

Асинхронний I/O (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 створить власний внутрішній пул потоків, який обслуговуватиме I/O-події. Для простих задач цього достатньо, але для серверних застосунків краще керувати пулом самостійно.

3. Потоки-виконавці (ExecutorService) та їхня роль

Коли ви працюєте з асинхронним каналом, десь за кулісами Java має виконати ваші зворотні виклики (callback-и) або завершити Future. Робить вона це не магією, а за допомогою спеціальних робочих потоків — ExecutorService.

Якщо ви не передаєте свій пул потоків, Java просто створює внутрішній — зазвичай один потік на кожен процесор. Зручно, але не завжди безпечно. Коли ж ви хочете самі керувати тим, скільки потоків працює, які завдання важливіші та як розподіляється навантаження, краще створити свій ExecutorService і передати його в open.

У серверних застосунках це особливо важливо. Без власного пулу потоків можна легко отримати несподівані сплески навантаження — і замість плавної роботи сервер почне задихатися.

Приклад:

ExecutorService pool = Executors.newFixedThreadPool(8);

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

Вплив вибору пулу:

• Багато потоків — більше паралелізму, але й більше навантаження на систему.
• Мало потоків — менше одночасних операцій, але менші накладні витрати.
• Якщо ви запускаєте тисячі асинхронних операцій, подумайте про баланс!

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 синхронне читання

Схема роботи асинхронного I/O

6. Типові помилки під час роботи з AsynchronousFileChannel

Помилка № 1: забули закрити канал.
AsynchronousFileChannel — це ресурс, який потрібно закривати. Якщо забути закрити канал (channel.close() або try-with-resources), можна отримати витоки дескрипторів і проблеми з доступом до файлів. Використовуйте try-with-resources завжди, коли це можливо.

Помилка № 2: блокувальний get() в основному потоці.
Якщо ви використовуєте Future і викликаєте get() у головному потоці (наприклад, в UI-застосунку), ви втрачаєте сенс асинхронного I/O — потік усе одно чекатиме. Використовуйте CompletionHandler або окремий потік для очікування результату.

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

Помилка № 4: забули обробити помилки.
Асинхронні операції можуть завершитися з помилкою (наприклад, файл не знайдено, немає доступу). Якщо не обробити винятки в CompletionHandler або не перевірити Future на помилку, програма «мовчки» не виконає операцію.

Помилка № 5: не врахований паралелізм.
Якщо ви запускаєте кілька операцій на одному каналі одночасно, переконайтеся, що ваш код потокобезпечний і не виникають стани гонки за буфери або позиції файлу.