На что ориентируется NIO?

На что ориентируется NIO (Java NIO)

NIO ориентируется на асинхронный, неблокирующий I/O с использованием буферов, каналов и селекторов. Это полная переработка классической IO модели Java, предназначенная для высокопроизводительных приложений, обрабатывающих множество одновременных соединений.

NIO vs BIO (Blocking IO)

BIO (Traditional Blocking IO)

// Традиционный IO - блокирующий
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
    Socket client = serverSocket.accept();  // БЛОКИРУЕТ, ждет клиента
    InputStream input = client.getInputStream();
    byte[] buffer = new byte[1024];
    int bytesRead = input.read(buffer);      // БЛОКИРУЕТ, ждет данных
    // Процесс одного клиента
}

Проблемы:

• На каждый клиент нужен отдельный поток
• 1000 клиентов = 1000 потоков (дорого)
• Context switching замедляет систему
• Масштабируемость ограничена

NIO (Non-Blocking IO)

// NIO - неблокирующий
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);  // Неблокирующий режим!

Selector selector = Selector.open();
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();  // Ждет готовности канала (non-blocking)
    Set<SelectionKey> keys = selector.selectedKeys();
    // Обрабатывает ТОЛЬКО готовые каналы
}

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

• Один поток может управлять тысячами соединений
• Нет блокировки при отсутствии данных
• Минимум контекст-переключений
• Масштабируемость на миллионы соединений

Три столпа NIO

1. Буферы (Buffers)

Все данные в NIO работают через буферы, а не через потоки.

// Традиционный IO
InputStream input = socket.getInputStream();
byte[] data = new byte[1024];
input.read(data);  // Читает прямо в массив

// NIO
ByteBuffer buffer = ByteBuffer.allocate(1024);
SocketChannel channel = socket.getChannel();
channel.read(buffer);  // Читает в буфер
buffer.flip();  // Переводит в режим чтения
while (buffer.hasRemaining()) {
    byte b = buffer.get();
}

Виды буферов:

ByteBuffer buffer = ByteBuffer.allocate(1024);      // На heap
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);  // Native memory

// Другие типы буферов
CharBuffer charBuffer = CharBuffer.allocate(1024);
IntBuffer intBuffer = IntBuffer.allocate(100);
LongBuffer longBuffer = LongBuffer.allocate(50);

Состояния буфера:

ByteBuffer buffer = ByteBuffer.allocate(10);

// Запись в буфер
buffer.put((byte) 65);      // position: 0 -> 1
buffer.put((byte) 66);      // position: 1 -> 2

// Подготовка к чтению
buffer.flip();              // position: 0, limit: 2

// Чтение
while (buffer.hasRemaining()) {
    System.out.println((char) buffer.get());  // A, B
}

// Очистка для новых данных
buffer.clear();             // position: 0, limit: 10

2. Каналы (Channels)

Бидиректиональные соединения для чтения и записи.

// Открытие канала
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress("localhost", 8080));
serverChannel.configureBlocking(false);

// Чтение и запись
SocketChannel clientChannel = serverChannel.accept();
if (clientChannel != null) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    
    // Чтение
    int bytesRead = clientChannel.read(buffer);
    
    // Запись
    buffer.flip();
    clientChannel.write(buffer);
}

Типы каналов:

ServerSocketChannel    // Слушает входящие подключения
SocketChannel          // Соединение TCP
DatagramChannel        // UDP
FileChannel            // Работа с файлами

3. Селектор (Selector)

Отслеживает готовность множества каналов в одном потоке.

// Создание селектора
Selector selector = Selector.open();

// Регистрация каналов
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
clientChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);

// Ожидание готовности (неблокирующий)
int readyChannels = selector.select();  // Ждет максимум 1 день
int readyChannels = selector.select(1000);  // Ждет максимум 1 секунду
int readyChannels = selector.selectNow();  // Не ждет, проверяет сразу

// Обработка готовых каналов
Set<SelectionKey> selectedKeys = selector.selectedKeys();
for (SelectionKey key : selectedKeys) {
    if (key.isAcceptable()) {
        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = channel.accept();
        clientChannel.configureBlocking(false);
        clientChannel.register(selector, SelectionKey.OP_READ);
    }
    if (key.isReadable()) {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        channel.read(buffer);
        // Обработка данных
    }
}

Практический пример: Echo сервер на NIO

public class EchoServer {
    private static final int PORT = 8080;
    
    public static void main(String[] args) throws IOException {
        // 1. Открываем селектор и серверный канал
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(PORT));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        System.out.println("Echo сервер слушает на порту " + PORT);
        
        // 2. Главный цикл
        while (true) {
            // Ждем готовности каналов
            int readyChannels = selector.select();
            if (readyChannels == 0) continue;
            
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectedKeys.iterator();
            
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                
                // 3. Обработка нового подключения
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    client.register(selector, SelectionKey.OP_READ, buffer);
                    System.out.println("Новое подключение: " + client.getRemoteAddress());
                }
                
                // 4. Чтение данных
                if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = (ByteBuffer) key.attachment();
                    
                    int bytesRead = client.read(buffer);
                    if (bytesRead > 0) {
                        // Подготовка буфера для отправки
                        buffer.flip();
                        client.write(buffer);
                        buffer.clear();
                    } else if (bytesRead < 0) {
                        // Клиент закрыл соединение
                        client.close();
                        key.cancel();
                    }
                }
                
                iterator.remove();
            }
        }
    }
}

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

✅ Используй NIO когда:

- Нужно обрабатывать тысячи одновременных соединений
- Высокие требования к throughput
- Работаешь с сокетами или файлами
- Нужна очень низкая задержка
- Пишешь веб-сервер или прокси

Примеры:

• Netflix Zuul (API Gateway) — использует NIO
• Play Framework — построен на NIO
• Jetty и другие веб-серверы

❌ Не используй NIO когда:

- Приложение обрабатывает мало соединений (< 1000)
- Код должен быть простым и понятным
- Работаешь с файловой системой последовательно
- Нет требований к высокой производительности

AIO (Asynchronous IO) — еще лучше

Для еще большей асинхронности Java имеет AIO (NIO.2):

AsynchronousServerSocketChannel server = 
    AsynchronousServerSocketChannel.open();
server.bind(new InetSocketAddress(8080));

// Асинхронный accept без селектора
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
    @Override
    public void completed(AsynchronousSocketChannel result, Void attachment) {
        // Новое подключение
    }
    
    @Override
    public void failed(Throwable exc, Void attachment) {
        // Ошибка
    }
});

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

Ключевые моменты NIO

1. Non-blocking — канал не блокируется при отсутствии данных
2. Selectors — один селектор управляет множеством каналов
3. Buffers — все данные проходят через буферы
4. Channels — бидиректиональные соединения
5. Масштабируемость — C10K problem решен

Вывод: NIO ориентируется на высокопроизводительную, неблокирующую обработку множества одновременных I/O соединений через буферы и селекторы в одном потоке. Это критический инструмент для современных веб-приложений и микросервисов.