В чем разница между Java IO и Java NIO?

Java IO vs Java NIO: Блокирующий vs Неблокирующий I/O

Это фундаментальное различие в подходах к работе с вводом-выводом. Выбор между ними может определить производительность всего приложения, особенно при работе с сетевыми соединениями.

Java IO (Input/Output) — Блокирующий I/O

Java IO (также называется BIO — Blocking I/O) — это оригинальный API для работы с потоками данных в Java. Это синхронный, блокирующий подход.

Как работает Java IO

import java.io.*;
import java.net.*;

public class TraditionalIOServer {
    public static void main(String[] args) throws IOException {
        // Создаём серверный сокет
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("Server listening on port 8080");
        
        while (true) {
            // БЛОКИРУЕТ здесь, пока не придёт клиент
            Socket clientSocket = serverSocket.accept();
            
            // Обработка одного клиента блокирует другие
            handleClient(clientSocket);
        }
    }
    
    // Блокирующие операции
    private static void handleClient(Socket socket) throws IOException {
        InputStream input = socket.getInputStream();
        OutputStream output = socket.getOutputStream();
        
        // БЛОКИРУЕТ на чтение
        byte[] buffer = new byte[1024];
        int bytesRead = input.read(buffer);  // Ждёт данных (может быть 10 сек!)
        
        // БЛОКИРУЕТ на запись
        String response = "HTTP/1.1 200 OK\r\n...";
        output.write(response.getBytes());  // Ждёт, пока данные отправятся
        
        socket.close();
    }
}

Проблема: потокоёмкость

Много клиентов → нужно много потоков → память → ☠️ OutOfMemoryError

Клиент 1 подключается        → создаём Thread 1
Клиент 2 подключается        → создаём Thread 2
Клиент 3 подключается        → создаём Thread 3
...
Клиент 10000 подключается    → создаём Thread 10000

Каждый поток = ~1-2 MB памяти
10000 потоков = 10-20 GB памяти! 💥

Визуально:

Традиционный IO (BIO)

Поток 1: ─[читаю]───[обрабатываю]───[пишу]───[свободен]
         ↑           ↑                 ↑
       БЛОК        БЛОК             БЛОК
         
Поток 2: ─────────[читаю]───[обрабатываю]───[пишу]───[свободен]
                   ↑           ↑                 ↑
                 БЛОК        БЛОК             БЛОК

Поток 3: ─────────────────[читаю]───[обрабатываю]───[пишу]
                            ↑           ↑                 ↑
                          БЛОК        БЛОК             БЛОК

Как видно — потоки много времени ждут, не делая полезную работу

Пример: Блокирующее чтение из файла

// Блокирующее чтение
FileInputStream fis = new FileInputStream("large-file.bin");
byte[] buffer = new byte[8192];

int bytesRead = fis.read(buffer);  // БЛОКИРУЕТ здесь, пока не прочитает
System.out.println("Read: " + bytesRead + " bytes");
// Ничего не происходит, пока читаются данные

fis.close();

Java NIO (New Input/Output) — Неблокирующий I/O

Java NIO (добавлена в Java 1.4, переработана в Java 7 как NIO.2) — это асинхронный, неблокирующий подход.

Как работает Java NIO

import java.nio.channels.*;
import java.nio.*;
import java.net.InetSocketAddress;
import java.util.*;

public class NIOServer {
    public static void main(String[] args) throws IOException {
        // 1. Создаём Selector — мультиплексор
        Selector selector = Selector.open();
        
        // 2. Создаём ServerSocketChannel (неблокирующий)
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);  // НЕ БЛОКИРУЮЩИЙ!
        serverChannel.bind(new InetSocketAddress(8080));
        
        // 3. Регистрируем канал в Selector
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        System.out.println("NIO Server listening on port 8080");
        
        while (true) {
            // 4. Ждём событий (но не блокируемся полностью)
            int readyChannels = selector.select();  // Неблокирующий wait
            
            if (readyChannels == 0) continue;
            
            // 5. Обрабатываем ВСЕ готовые события
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectedKeys.iterator();
            
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                
                if (key.isAcceptable()) {
                    // Новый клиент
                    handleAccept(key, selector);
                } else if (key.isReadable()) {
                    // Данные готовы к чтению
                    handleRead(key);
                } else if (key.isWritable()) {
                    // Готовы писать
                    handleWrite(key);
                }
                
                iterator.remove();
            }
        }
    }
    
    private static void handleAccept(SelectionKey key, Selector selector) throws IOException {
        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = channel.accept();
        clientChannel.configureBlocking(false);
        
        // Регистрируем для чтения
        clientChannel.register(selector, SelectionKey.OP_READ);
        System.out.println("Client connected: " + clientChannel.getRemoteAddress());
    }
    
    private static void handleRead(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        
        int bytesRead = channel.read(buffer);  // НЕ БЛОКИРУЕТ, если нет данных
        
        if (bytesRead == -1) {
            channel.close();
        } else if (bytesRead > 0) {
            System.out.println("Read: " + bytesRead + " bytes");
        }
    }
    
    private static void handleWrite(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.wrap("Hello Client\n".getBytes());
        channel.write(buffer);
    }
}

Преимущество: масштабируемость

NIO Server может обработать миллионы клиентов на одном потоке!

Один Selector + неблокирующие каналы + небольшой thread pool

Селектор: ─[ждёт событий]─ ─[получила событие от клиента 1]─
                          │  [получила событие от клиента 2]
                          │  [получила событие от клиента 3]
                          └─ Распределяет работу потокам

Сравнительная таблица

                    Java IO (BIO)           Java NIO
─────────────────────────────────────────────────────────
Модель              Блокирующая             Неблокирующая

Поток на клиента    Да (1 поток = 1 клиент) Нет (N клиентов на М потоках)

Память              Высокая (1-2 MB/поток) Низкая (каналы лёгкие)

Масштабируемость    ~1000 клиентов         ~100000+ клиентов

Производитель       Слабая (ждут потоки)   Сильная (активная работа)

Сложность           Простая                 Сложная (Selector, ByteBuffer)

Апи                 InputStream/OutputStream Channels, ByteBuffer

Оперативность       Хорошая для малых       Превосходная для больших
                    систем                  нагрузок

Мультиплексинг      Через потоки            Через Selector (ОС level)

Практические примеры

Java IO — идеален для файловых операций

// Простое чтение файла
public static void readFile(String filename) throws IOException {
    try (FileInputStream fis = new FileInputStream(filename);
         BufferedInputStream bis = new BufferedInputStream(fis)) {
        
        byte[] buffer = new byte[8192];
        int bytesRead;
        
        while ((bytesRead = bis.read(buffer)) != -1) {
            processData(buffer, bytesRead);
        }
    }
}

Java NIO — идеален для сетевых серверов

// Асинхронный веб-сервер (упрощённо)
public class AsyncWebServer {
    public void start() throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(8080));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        System.out.println("Server can handle 100000+ concurrent clients");
        
        while (selector.select() > 0) {
            for (SelectionKey key : selector.selectedKeys()) {
                if (key.isAcceptable()) {
                    acceptConnection(key, selector);
                } else if (key.isReadable()) {
                    readRequest(key);
                } else if (key.isWritable()) {
                    writeResponse(key);
                }
            }
            selector.selectedKeys().clear();
        }
    }
}

Современные альтернативы

// Java 7+ — NIO.2 (AsynchronousChannelGroup)
AsynchronousServerSocketChannel server = 
    AsynchronousServerSocketChannel.open();

// Reactive фреймворки (Project Reactor, RxJava)
Flux.interval(Duration.ofSeconds(1))
    .subscribe(System.out::println);

// Netty — популярный фреймворк, встроенный в Spring WebFlux
// Спрятывает сложность NIO за простым API

Когда использовать что

Java IO:

• Файловые операции
• Простые CLI приложения
• Работа с локальными файлами
• Когда простота важнее производительности

Java NIO:

• Веб-серверы (Tomcat, Netty)
• Высоконагруженные приложения
• Много одновременных соединений
• Когда нужна масштабируемость

Практическое правило:

• До 1000 одновременных клиентов → Java IO OK
• Больше 1000 → Java NIO или async frameworks

Вывод

Java IO хороша для простых случаев, но Java NIO необходима для масштабируемых сетевых приложений. В современных приложениях обычно используются high-level фреймворки (Spring WebFlux, Vert.x, Netty), которые спрятывают сложность NIO за удобным API.