当前位置：首页 > article >正文

Java NIO 高并发开发

article 2024/9/25 11:19:10

Java NIO 高并发开发

前言

Java NIO（New I/O）相比于传统的Java I/O（BIO）在高并发开发方面具有以下优势：

非阻塞模式：Java NIO使用非阻塞的I/O操作，允许一个线程管理多个通道（Channel），并且在没有数据可读写时不会阻塞线程。这意味着一个线程可以同时处理多个连接，而不需要为每个连接创建一个独立的线程，从而大大减少了线程的数量和上下文切换的开销。

选择器（Selector）：Java NIO提供了Selector机制，通过Selector可以同时监控多个通道的事件（如可读、可写、连接等）。一个Selector可以管理多个通道，通过单个线程监听多个通道上的事件，避免了为每个通道创建独立线程的开销。

缓冲区（Buffer）：Java NIO使用缓冲区进行数据的读写操作，通过将数据从通道读取到缓冲区中，或者将数据从缓冲区写入到通道中，可以提高数据的处理效率。此外，缓冲区还可以进行批量读写操作，减少了系统调用的次数，提高了性能。

零拷贝（Zero-copy）：Java NIO支持零拷贝技术，即数据在内核空间和用户空间之间的传输可以避免数据的拷贝。在传统的Java I/O中，数据需要从内核缓冲区拷贝到用户缓冲区，然后再进行处理，而Java
NIO可以直接在内核缓冲区和用户缓冲区之间进行操作，减少了数据拷贝的开销。

综上所述，Java
NIO通过非阻塞模式、选择器、缓冲区和零拷贝等特性，使得一个线程可以同时管理多个通道，大大提高了系统的并发性能。相比于传统的Java
I/O，它能更有效地利用系统资源，减少线程数量和上下文切换的开销，适用于高并发的网络应用程序开发。然而，需要注意的是，Java
NIO相对复杂，需要处理多线程同步、数据一致性等问题，因此在使用时需要谨慎处理各种可能的事件和异常情况。
在我发这篇文章之前，我已经发过NIO的基础用法和全套NIO用法，可以看之前我发的文章Java NIO 和Java NIO 开发

一，Java NIO 高并发示例代码模板

当然，我会为你提供带有注释的Java NIO高并发开发示例代码。以下是一个考虑到并发、线程安全、锁竞争、异常处理、线程池配置和内存管理的示例代码：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NIOConcurrencyExample {
    private static final int BUFFER_SIZE = 1024;
    private static final int THREAD_POOL_SIZE = 10;

    public static void main(String[] args) throws IOException {
        // 创建 Selector 对象
        Selector selector = Selector.open();

        // 创建 ServerSocketChannel 并绑定端口
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);

        while (true) {
            // 等待就绪的通道
            int readyChannels = selector.select();
            if (readyChannels == 0) {
                continue;
            }

            // 获取就绪通道的 SelectionKey 集合
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();

                if (key.isAcceptable()) {
                    // 接受新的客户端连接请求
                    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = serverChannel.accept();
                    clientChannel.configureBlocking(false);
                    clientChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    // 处理读取事件的线程
                    executorService.execute(() -> {
                        try {
                            SocketChannel clientChannel = (SocketChannel) key.channel();
                            ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
                            int bytesRead = clientChannel.read(buffer);

                            // 处理读取到的数据
                            while (bytesRead > 0) {
                                buffer.flip();
                                // TODO: 处理数据逻辑
                                buffer.clear();
                                bytesRead = clientChannel.read(buffer);
                            }

                            if (bytesRead == -1) {
                                clientChannel.close();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    });
                }

                keyIterator.remove();
            }
        }
    }
}