Является ли NIO потокоорентируемым?

Является ли NIO потокоориентированным?

Это распространённый вопрос о различиях между Traditional I/O (BIO) и NIO (New I/O). Ответ: НЕТ, NIO НЕ является потокоориентированным — это его главное преимущество.

Сравнение BIO vs NIO

BIO (Blocking I/O) — потокоориентированный:

// Traditional Socket - блокирующий ввод-вывод
public void handleConnections() {
    ServerSocket serverSocket = new ServerSocket(8080);
    
    while (true) {
        Socket socket = serverSocket.accept();  // БЛОКИРУЕТ поток!
        
        // Создаём новый поток для каждого клиента
        Thread thread = new Thread(() -> {
            try (InputStream in = socket.getInputStream()) {
                byte[] buffer = new byte[1024];
                int bytesRead = in.read(buffer);  // БЛОКИРУЕТ поток!
                
                // Обработка данных
                processData(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        
        thread.start();
    }
}

// Проблема: если 10,000 клиентов - 10,000 потоков!
// Context switching, высокое потребление памяти

NIO (Non-blocking I/O) — не потокоориентированный:

// NIO Selector - один поток может обрабатывать много каналов
public void handleConnectionsNIO() throws IOException {
    ServerSocketChannel serverChannel = ServerSocketChannel.open();
    serverChannel.bind(new InetSocketAddress(8080));
    serverChannel.configureBlocking(false);  // Non-blocking mode
    
    Selector selector = Selector.open();
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    while (true) {
        selector.select();  // Ждёт событий (не блокирует CPU)
        
        Set<SelectionKey> keys = selector.selectedKeys();
        Iterator<SelectionKey> iterator = keys.iterator();
        
        while (iterator.hasNext()) {
            SelectionKey key = iterator.next();
            iterator.remove();
            
            if (key.isAcceptable()) {
                // Новое подключение
                ServerSocketChannel server = (ServerSocketChannel) key.channel();
                SocketChannel client = server.accept();
                client.configureBlocking(false);
                client.register(selector, SelectionKey.OP_READ);
                
            } else if (key.isReadable()) {
                // Данные готовы для чтения
                SocketChannel client = (SocketChannel) key.channel();
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                client.read(buffer);
                processData(buffer);
            }
        }
    }
}

// Преимущество: один поток может обрабатывать 1000+ клиентов!

Ключевые различия

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

public void demonstrateSelector() throws IOException {
    // Создаём Selector - регистрирует каналы для мониторинга
    Selector selector = Selector.open();
    
    // Создаём канал и регистрируем его
    ServerSocketChannel channel = ServerSocketChannel.open();
    channel.configureBlocking(false);
    channel.bind(new InetSocketAddress(8080));
    
    // Интересуют события: новые подключения
    SelectionKey key = channel.register(selector, SelectionKey.OP_ACCEPT);
    
    // Главный цикл
    while (true) {
        // selector.select() ждёт, пока не будут готовы каналы
        // Это не CPU-интенсивно (не polling)
        int readyChannels = selector.select(1000);  // timeout 1 сек
        
        if (readyChannels == 0) continue;
        
        Set<SelectionKey> selectedKeys = selector.selectedKeys();
        Iterator<SelectionKey> iterator = selectedKeys.iterator();
        
        while (iterator.hasNext()) {
            SelectionKey selectedKey = iterator.next();
            
            // Проверяем, какое событие произошло
            if (selectedKey.isAcceptable()) {
                handleAccept(selectedKey);
            } else if (selectedKey.isReadable()) {
                handleRead(selectedKey);
            } else if (selectedKey.isWritable()) {
                handleWrite(selectedKey);
            }
            
            iterator.remove();
        }
    }
}

private void handleRead(SelectionKey key) throws IOException {
    SocketChannel channel = (SocketChannel) key.channel();
    ByteBuffer buffer = ByteBuffer.allocate(256);
    
    int bytesRead = channel.read(buffer);  // НЕБЛОКИРУЮЩЕЕ чтение
    
    if (bytesRead == -1) {
        channel.close();
        key.cancel();
    } else {
        // Обработка данных
        buffer.flip();
        processBuffer(buffer);
    }
}

Реальный пример: Netty использует NIO

// Netty - фреймворк, построенный на NIO
// Использует Selector для обработки множества подключений

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();

ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
    .channel(NioServerSocketChannel.class)
    .childHandler(new ChannelInitializer<SocketChannel>() {
        @Override
        protected void initChannel(SocketChannel ch) throws Exception {
            ch.pipeline().addLast(new MyHandler());
        }
    });

bootstrap.bind(8080).sync();

// workerGroup содержит несколько потоков (обычно = CPU cores)
// Каждый поток обрабатывает тысячи клиентов через Selector!

Java NIO компоненты

// 1. Channel - представляет открытое соединение
SocketChannel channel = SocketChannel.open();

// 2. Buffer - хранит данные
ByteBuffer buffer = ByteBuffer.allocate(1024);

// 3. Selector - мониторит множество каналов
Selector selector = Selector.open();
channel.register(selector, SelectionKey.OP_READ);

// 4. SelectionKey - представляет регистрацию канала в Selector
int readyChannels = selector.select();
Set<SelectionKey> keys = selector.selectedKeys();

Заключение

• NIO НЕ потокоориентирован — это его главное преимущество
• BIO потокоориентирован: 1 поток на клиента
• NIO событийно-ориентирован: 1 поток на Selector, множество клиентов
• Selector — ядро NIO, мониторит события на каналах
• Масштабируемость: NIO обрабатывает 10,000+ клиентов, BIO — сотни
• Примеры: Netty, Tomcat, Redis используют NIO для высокой производительности

Это критическое понимание для работы с высоконагруженными приложениями в Java.