Как создать отдельный поток для I/O операции?

# Создание отдельного потока для I/O операции

I/O операции (ввод-вывод) блокируют выполнение потока. Для избежания блокировки основного потока часто создают отдельные потоки. Рассмотрим разные подходы.

1. Использование Thread (Классический подход)

Создание нового потока вручную:

public class FileReaderWithThread {
    public static void main(String[] args) {
        // Создаём новый поток для I/O операции
        Thread ioThread = new Thread(() -> {
            try {
                String content = readFile("/path/to/file.txt");
                System.out.println("Файл прочитан: " + content);
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        
        // Запускаем поток
        ioThread.start();
        
        // Основной поток продолжает работу
        System.out.println("Чтение файла происходит в отдельном потоке");
        
        // Ждём завершения I/O потока (опционально)
        try {
            ioThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    static String readFile(String path) throws IOException {
        return new String(java.nio.file.Files.readAllBytes(
            java.nio.file.Paths.get(path)));
    }
}

Минусы:

• Создание потока имеет overhead
• Сложно управлять множеством потоков
• Нет переиспользования потоков

2. Thread Pool (ExecutorService) — Рекомендуется

Использование пула потоков для эффективного управления:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.io.IOException;

public class FileReaderWithThreadPool {
    public static void main(String[] args) {
        // Создаём пул из 5 потоков
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        try {
            // Отправляем I/O задачу в пул
            Future<String> future = executor.submit(() -> {
                return readFile("/path/to/file.txt");
            });
            
            System.out.println("Основной поток продолжает работу");
            
            // Получаем результат когда I/O завершится (блокирует)
            String content = future.get();
            System.out.println("Результат: " + content);
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown(); // Завершаем пул потоков
        }
    }
    
    static String readFile(String path) throws IOException {
        return new String(java.nio.file.Files.readAllBytes(
            java.nio.file.Paths.get(path)));
    }
}

Преимущества:

• Переиспользование потоков
• Простое управление
• Меньше overhead

3. Асинхронные I/O (Non-blocking) — Лучший подход

Для по-настоящему асинхронных операций используйте CompletableFuture:

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.io.IOException;

public class AsyncFileReader {
    private static ExecutorService executor = Executors.newFixedThreadPool(5);
    
    public static void main(String[] args) {
        // Асинхронное чтение файла
        CompletableFuture<String> future = readFileAsync("/path/to/file.txt")
            .thenApply(content -> "Обработан файл: " + content)
            .thenAccept(System.out::println)
            .exceptionally(ex -> {
                System.err.println("Ошибка: " + ex.getMessage());
                return null;
            });
        
        System.out.println("Основной поток продолжает работу, не дожидаясь результата");
        
        // Даём время для завершения
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        executor.shutdown();
    }
    
    static CompletableFuture<String> readFileAsync(String path) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return readFile(path);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }, executor);
    }
    
    static String readFile(String path) throws IOException {
        return new String(java.nio.file.Files.readAllBytes(
            java.nio.file.Paths.get(path)));
    }
}

4. Reactive программирование (Project Reactor)

Для современных асинхронных приложений:

import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;

public class ReactiveFileReader {
    public static void main(String[] args) {
        Mono<String> fileContent = Mono.fromCallable(() -> 
            readFile("/path/to/file.txt")
        )
        .subscribeOn(Schedulers.boundedElastic()) // I/O операция в отдельном потоке
        .map(content -> "Обработан: " + content)
        .doOnError(ex -> System.err.println("Ошибка: " + ex.getMessage()));
        
        System.out.println("Основной поток продолжает работу");
        
        // Подписываемся на результат
        fileContent.subscribe(System.out::println);
        
        // Даём время для завершения
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    static String readFile(String path) throws Exception {
        return new String(java.nio.file.Files.readAllBytes(
            java.nio.file.Paths.get(path)));
    }
}

5. Virtual Threads (Java 19+) — Будущее

Очень лёгкие потоки для масштабирования:

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

public class VirtualThreads {
    public static void main(String[] args) {
        // Пул виртуальных потоков (можно создавать миллионы)
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        try {
            // Каждая I/O операция в отдельном виртуальном потоке
            var future = executor.submit(() -> readFile("/path/to/file.txt"));
            System.out.println("Основной поток продолжает работу");
            String content = future.get();
            System.out.println("Результат: " + content);
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
    
    static String readFile(String path) throws Exception {
        return new String(java.nio.file.Files.readAllBytes(
            java.nio.file.Paths.get(path)));
    }
}

6. Обработка нескольких I/O операций

ExecutorService executor = Executors.newFixedThreadPool(3);
List<Future<String>> futures = new ArrayList<>();

// Запускаем несколько I/O операций
for (String filePath : filePaths) {
    Future<String> future = executor.submit(() -> readFile(filePath));
    futures.add(future);
}

// Собираем результаты
for (Future<String> future : futures) {
    try {
        String content = future.get(); // Может блокировать
        System.out.println("Результат: " + content);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

executor.shutdown();

Сравнение подходов

Лучшие практики

• Используйте ExecutorService вместо создания потоков вручную
• CompletableFuture для асинхронного программирования
• Закрывайте executor через shutdown()
• Обрабатывайте исключения в I/O операциях
• Не блокируйте основной поток на get()
• Для Java 19+ рассмотрите Virtual Threads