Что позволяет совершить неблокирующие чтение?

Неблокирующие чтение (Non-blocking Read)

Неблокирующее чтение позволяет приложению продолжить работу без ожидания завершения операции чтения. Это ключевой механизм для построения высокопроизводительных приложений.

Что позволяет совершить неблокирующее чтение

1. Обработка множественных соединений одним потоком

public class BlockingServer {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8080);
        while (true) {
            Socket client = server.accept();
            new Thread(() -> {
                // Нужен отдельный поток для каждого клиента
            }).start();
        }
    }
}

public class NonBlockingServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel server = ServerSocketChannel.open();
        server.configureBlocking(false);
        server.bind(new InetSocketAddress(8080));
        server.register(selector, SelectionKey.OP_ACCEPT);
        
        while (true) {
            int readyChannels = selector.select();
            // ОДИН поток может обработать 10000 соединений
        }
    }
}

2. Одновременное выполнение других задач

public class AsyncProcessor {
    public void processBlockingWay() throws IOException {
        InputStream in = socket.getInputStream();
        byte[] response = new byte[4096];
        in.read(response);
        System.out.println("Response");
    }
    
    public void processNonBlockingWay() throws IOException {
        SocketChannel channel = SocketChannel.open();
        channel.configureBlocking(false);
        channel.write(request);
        processOtherTasks();
    }
}

3. Масштабируемость на большое количество соединений

Блокирующий I/O: 100000 потоков, 95 ГБ памяти Неблокирующий I/O: 16 потоков, 8 МБ памяти

4. Лучшее использование CPU

Блокирующий поток тратит CPU впустую при ожидании I/O. Неблокирующий I/O - CPU работает на 100% без простоев.

Реактивное программирование

public class ReactiveExample {
    public void example() {
        Flux.range(1, 5)
            .map(i -> i * 2)
            .filter(i -> i > 5)
            .subscribe(System.out::println);
    }
}

@RestController
public class AsyncController {
    @GetMapping("/users/{id}")
    public Mono<User> getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @GetMapping("/users")
    public Flux<User> getAllUsers() {
        return userService.findAll();
    }
}

Java NIO 2

public class AsyncChannelExample {
    public static void main(String[] args) throws Exception {
        AsynchronousFileChannel channel = 
            AsynchronousFileChannel.open(Paths.get("file.txt"));
        
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        Future<Integer> result = channel.read(buffer, 0);
        
        System.out.println("Чтение в процессе");
        Integer bytesRead = result.get();
    }
}

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

Web сервер:

• Блокирующий (Tomcat): 1000 соединений
• Неблокирующий (Netty): 100000+ соединений

Микросервисы:

• Блокирующий: RestTemplate
• Неблокирующий: WebClient

Вывод

Неблокирующее чтение позволяет:

1. Обработать больше соединений с меньшим количеством потоков
2. Лучше использовать CPU
3. Масштабировать на десятки тысяч клиентов
4. Улучшить throughput и latency
5. Снизить потребление памяти

Модерные фреймворки (Spring WebFlux, Netty, Project Reactor) используют неблокирующий I/O для высоконагруженных приложений.