BIO、NIO、AIO 个人总结

BIO(blocking io)

BIO即为阻塞IO,在网络编程中,它会在建立连接和等待连接的对端准备数据阶段进行阻塞。因此为了支撑高并发的用户访问,一般会为每一个socket 连接分配一个线程。但使用的瓶颈更加明显,无法支持上百万、甚至千万以上的并发。且线程切换带来的开销也更大。

BIO.png

代码示例:

Server端

  1. Server 端绑定 8082 端口
  2. 通过 accept() 方法 阻塞等待客户端建立连接
  3. 当与客户端建立一个 socket 连接通道之后,server 端口将新建一个线程进行 【读】 、【写】
    ( ps: 这里的读是阻塞的,因为当server端发起读的请求时,如果此时对端未准备好数据,那么将一直阻塞等待 。
    直到:1. 对端通过 socket 发送数据2. 将数据从内核态 拷贝到用户态
    )

try {
            // 绑定本地 8082 端口
            ServerSocket server = new ServerSocket(8082);
            while (true) {
                //阻塞等待客户端 socket 建立连接
                Socket accept = server.accept();
                Thread t = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        // 一个线程处理一个socket 连接
                        BufferedReader reader = null;
                        PrintWriter out = null;
                        try {
                            reader = new BufferedReader(new InputStreamReader(accept.getInputStream()));
                            String readLine = reader.readLine();
                            System.out.println("receive message is " + readLine);
                            out = new PrintWriter(accept.getOutputStream(), true);
                            out.println("接收完毕,请继续发送!");
                        } catch (IOException e) {
                            e.printStackTrace();
                        } finally {
                            if (accept != null) {
                                try {
                                    accept.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                });
                t.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

Client端

  1. 与 server 建立连接的过程,会阻塞
    2.建立连接之后 ,便可通过获取 socket 的 输入、输出流进行读写
    (ps : 与 server 端原因相同,读的时候也会阻塞)
        //阻塞等待连接建立
        Socket socket = new Socket("localhost", 8082);
        //处理数据
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(), true);
            out.println("Now establish connection");
            System.out.println("从 server 端收到连接信息:" + in.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }

NIO (no blocking io 也叫 new io)

NIO 即非阻塞IO,是JDK 1.4 更新的api, 核心内容是 将建立连接、数据可读、可写等事件交给了操作系统来维护, 通过调用操作系统的 api (如:select、epoll等),来判断当前是否支持:可读、可写,如果当前不可操作,那么直接返回,从而实现了非阻塞。 而不需要像 BIO 那样每次去轮询等待连接的建立以及数据的准备是否完成。主要核心的模块分以下几类:

1. 缓冲区Buffer

一个特定基类(byte、short、int、long 等)的数据容器,用作在建立socket 连接之后的数据传输。
通过 capacity, limit, position,mark 指针来实现数据的读写

get()、put() 方法为每个子类都具有的读、写数据的api方法,当从当前的 position 读或写的同时,position会增加 相应读写的数据的长度。当position 达到limit 之后,再次 get、put则会抛出异常

2. Channel 连接通道

一个 channel 代表一个与“实体”的连接通道,如:硬件设备、文件、网络 socket 。通过连接通道可以使得客户端-服务器互相传输数据,因此通道也是全双工的(因为是建立在TCP 传输层的协议上,因此具备全双工的能力)。

JDK 中 channel 可以分为以下几类:

  • SelectableChannel 用于 阻塞和非阻塞 socket 连接的通道
  • FileChannel 用于文件操作,包括:reading, writing, mapping, and manipulating a file

3.Selector 多路复用选择器

用于 SelectableChannel 的多路复用器,当使用非阻塞的 socket 时,需要将监听的通道 SelectableChannel 感兴趣的事件注册到 selector 多路复用器上(selector 实际上是通过调用操作系统层面的 select、epoll 方法来获取当前可用的时间)

与之对应的感兴趣的事件用 SelectionKey 来表示

  • OP_READ = 1 << 0; 可读
  • OP_WRITE = 1 << 2; 可写
  • OP_CONNECT = 1 << 3; // 完成连接
  • OP_ACCEPT = 1 << 4; // 接收连接

处理流程图:

NIO .png

代码示例:

  1. 通过 ServerSocketChannel 监听 8082 端口
  2. 设置为非阻塞
  3. 选择与操作系统适配的选择器,serverSocketChannel 的 OP_ACCEPT 事件注册到 selector 选择器上
  4. 当OP_ACCEPT 事件触发时,将所有建立好的Socketchannel 连接的感兴趣的事件(这里为 read事件)再次注册到Selector 上
        // 1.根据操作系统选择适当的底层 io复用方法
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8082));
        //2.设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //3.选择与操作系统适配的选择器
        Selector selector = Selector.open();
        //将 serverSocket 的OP_ACCEPT 事件注册到 selector 选择器上
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            // 4.监听当前连接建立情况
            int select = selector.select();
            if (select > 0) {
                //判断连接业务类型
                Set<SelectionKey> set = selector.selectedKeys();
                Iterator<SelectionKey> iterator = set.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();
                    //建立连接
                    if (key.isAcceptable()) {
                        ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                        //通过 accept 方法获取与 server端 已经创建好的 socket连接
                        SocketChannel sc = ssc.accept();
                        //设置为非阻塞
                        sc.configureBlocking(false);
                        //注册感兴趣的事件为 READ
                        sc.register(selector, SelectionKey.OP_READ);
                    }
                    //可读
                    else if (key.isReadable()) {
                        SocketChannel socket = (SocketChannel) key.channel();
                        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                        socket.read(byteBuffer);
                        System.out.println(new String(byteBuffer.array(), StandardCharsets.UTF_8));
                        key.interestOps(SelectionKey.OP_WRITE);
                    }
                    //可写
                    else if (key.isWritable()) {
                        SocketChannel socket = (SocketChannel) key.channel();
                        socket.write(ByteBuffer.wrap("I'm receive your message".getBytes(StandardCharsets.UTF_8)));
                        socket.close();
                        System.out.println("连接关闭成功!");
                    }
                }
            }
        }

AIO(asynchronous io)

NIO 2.0引入了新的异步通道的概念,并提供了异步文件通道和异步套接字通道的实现。
    异步的套接字通道时真正的异步非阻塞I/O,对应于UNIX网络编程中的事件驱动I/O(AIO)。他不需要过多的Selector对注册的通道进行轮询即可实现异步读写,从而简化了NIO的编程模型。

代码示例

   private static void server() throws IOException {
        //根据操作系统建立对应的底层操作类
        AsynchronousServerSocketChannel channel = AsynchronousServerSocketChannel.open();
        channel.bind(new InetSocketAddress(8082));
        while (true) {
            Future<AsynchronousSocketChannel> future = channel.accept();
            try {
                AsynchronousSocketChannel asc = future.get();
                System.out.println("建立连接成功");
                Future<Integer> write = asc.write(ByteBuffer.wrap("Now let's exchange datas".getBytes(StandardCharsets.UTF_8)));
                while (!write.isDone()) {
                    TimeUnit.SECONDS.sleep(2);
                }
                System.out.println("发送数据完成");
                asc.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static void client() throws Exception {
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        Future<Void> future = socketChannel.connect(new InetSocketAddress(8082));
        while (!future.isDone()) {
            TimeUnit.SECONDS.sleep(2);
        }
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        Future<Integer> read = socketChannel.read(buffer);
        while (!read.isDone()) {
            TimeUnit.SECONDS.sleep(2);
        }
        System.out.println("接收服务器数据:" + new String(buffer.array(), 0, read.get()));
    }
posted @ 2019-08-22 16:38  coding400  阅读(397)  评论(0编辑  收藏  举报