Что означает неблокируемый доступ к ресурсам в NIO?

# Что означает неблокируемый доступ к ресурсам в NIO?

Краткий ответ

Неблокируемый (non-blocking) доступ в NIO означает, что операции чтения/записи не приостанавливают поток. Если данные недоступны, операция сразу возвращает управление, позволяя потоку обработать другие задачи. Один поток может обслуживать тысячи соединений.

Блокирующий vs Неблокирующий доступ

1. Традиционный IO (Blocking)

// java.io - БЛОКИРУЮЩИЙ доступ
InputStream in = socket.getInputStream();

// Поток ЖДЁТ данных (блокирован!)
// Если данных нет, поток просто спит и ничего не делает
int data = in.read();  // БЛОКИРУЕТ поток здесь!

System.out.println("Получены данные: " + data);

// Если данных 30 секунд нет - поток 30 сек просто ждёт!
// Он не может ничего другого делать

Проблема:

ServerSocket serverSocket = new ServerSocket(8080);

// Обслуживаем клиентов
while (true) {
    // Ждём нового клиента (БЛОКИРУЕТ)
    Socket clientSocket = serverSocket.accept();  // БЛОКИРУЕТ!
    
    // Обслуживаем клиента (БЛОКИРУЕТ)
    InputStream in = clientSocket.getInputStream();
    int data = in.read();  // БЛОКИРУЕТ!
    
    // Пока обслуживаем одного клиента - остальные ждут!
    // Нужен новый поток на каждого клиента
    Thread thread = new Thread(() -> handleClient(clientSocket));
    thread.start();
}

2. NIO (Non-Blocking)

// java.nio - НЕБЛОКИРУЮЩИЙ доступ
SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false);  // Неблокирующий режим!

// Попытка прочитать
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(buffer);  // НЕ БЛОКИРУЕТ!

// bytesRead может быть:
// > 0: прочитали данные
// = 0: данные недоступны, но это не ошибка!
// = -1: соединение закрыто

if (bytesRead == 0) {
    // Данных нет, но мы можем обработать другие соединения!
    System.out.println("Нет данных, но поток свободен");
}

Механизм NIO

1. Channels (Каналы)

Вместо потоков данных используются двунаправленные каналы:

// Блокирующее соединение
Socket socket = new Socket("localhost", 8080);
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
// Отдельные потоки input/output

// Неблокирующее соединение через NIO
SocketChannel channel = SocketChannel.open(
    new InetSocketAddress("localhost", 8080)
);
channel.configureBlocking(false);  // Вот ключевое слово!
// Один канал для input/output, оба неблокирующие

2. Selectors (Селекторы)

Один поток мониторит множество каналов:

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

// Регистрируем каналы в селекторе
SocketChannel channel1 = SocketChannel.open();
channel1.configureBlocking(false);
channel1.register(selector, SelectionKey.OP_READ);  // Интересуют события READ

SocketChannel channel2 = SocketChannel.open();
channel2.configureBlocking(false);
channel2.register(selector, SelectionKey.OP_READ);

// ... ещё 10000 каналов!

// Один поток мониторит все каналы
while (true) {
    // Ждём СОБЫТИЙ (не данных!) - это тоже неблокирующее!
    int readyChannels = selector.select();  // Нажидается готовых каналов
    
    if (readyChannels == 0) continue;
    
    // Получаем только готовые к операции каналы
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    
    for (SelectionKey key : selectedKeys) {
        if (key.isReadable()) {
            SocketChannel channel = (SocketChannel) key.channel();
            
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            channel.read(buffer);  // НИКОГДА не блокирует!
            // Либо прочитали, либо нет - поток продолжает работу
        }
    }
}

Практический пример: Сервер

Блокирующий BIO (старый способ)

// Требует потока на каждого клиента
public class BIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO Server on 8080");
        
        while (true) {
            // БЛОКИРУЕТ: ждём клиента
            Socket clientSocket = serverSocket.accept();
            
            // Создаём новый поток для каждого клиента
            Thread thread = new Thread(() -> {
                try {
                    InputStream in = clientSocket.getInputStream();
                    OutputStream out = clientSocket.getOutputStream();
                    
                    // БЛОКИРУЕТ: ждём данных
                    byte[] buffer = new byte[1024];
                    int bytesRead = in.read(buffer);
                    
                    // Обрабатываем
                    String request = new String(buffer, 0, bytesRead);
                    String response = "Echo: " + request;
                    out.write(response.getBytes());
                    
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            thread.start();
            
            // 10000 клиентов = 10000 потоков!
            // Каждый поток весит ~1МБ памяти
            // Всего 10 GB памяти только на потоки!
        }
    }
}

Неблокирующий NIO (новый способ)

// Один поток обслуживает множество клиентов
public class NIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(8080));
        
        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        System.out.println("NIO Server on 8080");
        
        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();
                iterator.remove();
                
                if (key.isAcceptable()) {
                    // Новое соединение
                    ServerSocketChannel server = 
                        (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = server.accept();
                    clientChannel.configureBlocking(false);
                    
                    // Регистрируем для чтения
                    clientChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("Новый клиент");
                    
                } else if (key.isReadable()) {
                    // Данные готовы к чтению
                    SocketChannel clientChannel = 
                        (SocketChannel) key.channel();
                    
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = clientChannel.read(buffer);  // НЕ блокирует!
                    
                    if (bytesRead == -1) {
                        clientChannel.close();
                    } else if (bytesRead > 0) {
                        String request = new String(
                            buffer.array(), 0, bytesRead
                        );
                        
                        // Переключаемся на запись
                        clientChannel.register(selector, SelectionKey.OP_WRITE);
                        key.attach("Echo: " + request);
                    }
                    
                } else if (key.isWritable()) {
                    // Готовы писать
                    SocketChannel clientChannel = 
                        (SocketChannel) key.channel();
                    
                    String response = (String) key.attachment();
                    clientChannel.write(ByteBuffer.wrap(response.getBytes()));
                    clientChannel.close();
                }
            }
        }
    }
}

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

Примеры неблокирующих операций

SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false);

// 1. НЕБЛОКИРУЮЩЕЕ подключение
boolean connected = channel.connect(new InetSocketAddress("localhost", 8080));
if (!connected) {
    // Подключение в процессе, нужно доделать позже
    channel.register(selector, SelectionKey.OP_CONNECT);
}

// 2. НЕБЛОКИРУЮЩЕЕ чтение
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(readBuffer);  // НЕ блокирует!

// 3. НЕБЛОКИРУЮЩАЯ запись
ByteBuffer writeBuffer = ByteBuffer.wrap("Hello".getBytes());
int bytesWritten = channel.write(writeBuffer);  // НЕ блокирует!

// 4. selector.select() - полу-блокирующее (ждёт события, но время ограничено)
int readyCount = selector.select(1000);  // Ждёт макс 1 сек

Реальный пример: Netty Framework

// Netty инкапсулирует сложность NIO
@ChannelHandler.Sharable
public class EchoServerHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        // Это вызывается когда данные готовы
        // Фреймворк сам управляет selectors и channels!
        String response = "Echo: " + msg;
        ctx.writeAndFlush(response);
    }
}

public class EchoServer {
    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                     .channel(NioServerSocketChannel.class)
                     .childHandler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         public void initChannel(SocketChannel ch) {
                             ch.pipeline().addLast(new EchoServerHandler());
                         }
                     });
            
            ChannelFuture future = bootstrap.bind(8080).sync();
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

Почему это важно?

10000 одновременных соединений

BIO способ:
- 10000 потоков
- 10 * 1000 потоков * 1МБ = 10 GB памяти!
- Context switching overhead
- Медлено

NIO способ:
- 10-100 потоков
- 100 потоков * 1МБ = 100 МБ
- Минимальный context switching
- Быстро и масштабируемо

Заключение для интервью

"NIO предоставляет неблокирующий доступ к ресурсам, что означает операции чтения/записи сразу возвращают управление потоку, даже если данные недоступны. Это реализуется через Channels и Selectors - один поток может обслуживать тысячи соединений вместо создания потока на каждого клиента. NIO используется для высоконагруженных приложений с большим числом одновременных соединений.