Java 网络IO模型

已于 2023-10-24 16:17:43 修改
阅读量71 收藏 1
点赞数 2
分类专栏： 网络编程 文章标签： 1024程序员节 网络
于 2023-10-24 16:15:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40994080/article/details/134014375
版权

一篇文章带你彻底搞懂BIO，NIO，AIO。

BIO(Blocking IO)

同步阻塞模型，一个客户端连接对应一个处理线程。
在这里插入图片描述

代码示例

服务端代码

package nio.io.bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class BIOServer {
  public static void main(String[] args) throws IOException {
    ServerSocket serverSocket = new ServerSocket(8080);
    while (true) {
      System.out.println("server服务启动，等待连接。。");
      //等待客户端链接 阻塞方法
      Socket clientSocket = serverSocket.accept();
      System.out.println("客户端链接成功。。");
      handler(clientSocket);

            /*new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();*/
    }
  }

  private static void handler(Socket clientSocket) throws IOException {
    byte[] bytes = new byte[1024];
    System.out.println("准备read。。");
    //接收客户端的数据，阻塞方法，没有数据可读时就阻塞
    int read = clientSocket.getInputStream().read(bytes);
    System.out.println("read完毕。。");
    if (read != -1) {
      System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
    }
    clientSocket.getOutputStream().write("HelloClient".getBytes());
    clientSocket.getOutputStream().flush();
  }
}

客户端代码

package nio.io.bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class BIOClient {
  public static void main(String[] args) throws IOException {
    Socket socket = new Socket("localhost", 8080);
    //向服务端发送数据
    socket.getOutputStream().write("HelloServer".getBytes());
    socket.getOutputStream().flush();
    System.out.println("向服务端发送数据结束");
    byte[] bytes = new byte[1024];
    //接收服务端回传的数据
    socket.getInputStream().read(bytes);
    System.out.println("接收到服务端的数据：" + new String(bytes));
    socket.close();
  }
}

缺点
1、IO代码里read操作是阻塞操作，如果连接不做数据读写操作会导致线程阻塞，浪费资源
2、如果线程很多，会导致线程太多，压力太大，比如C10K问题

NIO(Non Blocking IO)

同步非阻塞模型，服务器实现模式为一个线程可以处理多个请求（连接），客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理。

基础版 NIO

public class NioServer {

  // 保存客户端连接
  static List<SocketChannel> channelList = new ArrayList<>();

  public static void main(String[] args) throws IOException, InterruptedException {

    // 创建NIO ServerSocketChannel,与BIO的serverSocket类似
    ServerSocketChannel serverSocket = ServerSocketChannel.open();
    serverSocket.socket().bind(new InetSocketAddress(9000));
    // 设置ServerSocketChannel为非阻塞
    serverSocket.configureBlocking(false);
    System.out.println("服务启动成功");

    while (true) {
      // 非阻塞模式accept方法不会阻塞，否则会阻塞
      // NIO的非阻塞是由操作系统内部实现的，底层调用了linux内核的accept函数
      SocketChannel socketChannel = serverSocket.accept();
      if (socketChannel != null) { // 如果有客户端进行连接
        System.out.println("连接成功");
        // 设置SocketChannel为非阻塞
        socketChannel.configureBlocking(false);
        // 保存客户端连接在List中
        channelList.add(socketChannel);
      }
      // 遍历连接进行数据读取
      Iterator<SocketChannel> iterator = channelList.iterator();
      while (iterator.hasNext()) {
        SocketChannel sc = iterator.next();
        ByteBuffer byteBuffer = ByteBuffer.allocate(128);
        // 非阻塞模式read方法不会阻塞，否则会阻塞
        int len = sc.read(byteBuffer);
        // 如果有数据，把数据打印出来
        if (len > 0) {
          System.out.println("接收到消息：" + new String(byteBuffer.array()));
        } else if (len == -1) { // 如果客户端断开，把socket从集合中去掉
          iterator.remove();
          System.out.println("客户端断开连接");
        }
      }
    }
  }
}

基础版Nio实现非常简单，就是当有客户端连接时，将客户端的channel保存到channelList中。遍历channeList，看看哪个客户端通过channel发送消息，将消息打印。

可这种形式，如果链接过多，会有大量的无效遍历浪费性能。举例子假如有10000个连接，其中只有1000个连接有写数据，但是由于其他9000个连接并没有断开，我们还是要每次轮询遍历一万次，其中有十分之九的遍历都是无效的。

引入多路复用器

来一张图直观感受一下吧
在这里插入图片描述

示例代码

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;

public class NioSelectorServer {

    public static void main(String[] args) throws IOException, InterruptedException {

        // 创建NIO ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        // 设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        // 打开Selector处理Channel，即创建epoll
        Selector selector = Selector.open();
        // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作感兴趣
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务启动成功");

        while (true) {
            // 阻塞等待需要处理的事件发生
            selector.select();

            // 获取selector中注册的全部事件的 SelectionKey 实例
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            // 遍历SelectionKey对事件进行处理
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // 如果是OP_ACCEPT事件，则进行连接获取和事件注册
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = server.accept();
                    socketChannel.configureBlocking(false);
                    // 这里只注册了读事件，如果需要给客户端发送数据可以注册写事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接成功");
                } else if (key.isReadable()) {  // 如果是OP_READ事件，则进行读取和打印
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                    int len = socketChannel.read(byteBuffer);
                    // 如果有数据，把数据打印出来
                    if (len > 0) {
                        System.out.println("接收到消息：" + new String(byteBuffer.array()));
                    } else if (len == -1) { // 如果客户端断开连接，关闭Socket
                        System.out.println("客户端断开连接");
                        socketChannel.close();
                    }
                }
                //从事件集合里删除本次处理的key，防止下次select重复处理
                iterator.remove();
            }
        }
    }
}

详细介绍
这也是NIO现在使用常用的形态了，让我们来详细了解一下这种形式吧。

NIO 有三大核心组件： Channel(通道)， Buffer(缓冲区)，Selector(多路复用器)
1、channel 类似于流，每个 channel 对应一个 buffer缓冲区，buffer 底层就是个数组
2、channel 会注册到 selector 上，由 selector 根据 channel 读写事件的发生将其交由某个空闲的线程处理
3、NIO 的 Buffer 和 channel 都是既可以读也可以写

关于多路复用器如何实现？channel如何注册到selector，selector如何管理channel，如何实现监听channel读写事件而不用遍历selector上全部的channel等这些需要了解Linux内核中epoll。

//创建多路复用器 ，其实底层就是创建Linux的epoll。
Selector.open()
//将channel注册到多路复用器上 ，也是将channel连接交给了Linux的epoll进行管理
socketChannel.register(selector, SelectionKey.OP_READ) 
//阻塞该线程等待需要处理的事件发生，等来epoll上注册的事件响应从而唤起该线程这一步不再阻塞
selector.select()

NIO整个调用流程就是Java调用了操作系统内核函数来创建Socket，在创建一个Selector对象，对应操作系统的Epoll描述符，将获取到的Socket连接的文件描述符的事件绑定到Selector对应的Epoll文件描述符上，进行事件的异步通知，这样实现了使用一条线程，并且不需要太多的无效遍历，将事件处理交给了操作系统内核（操作系统中断程序实现），大大提高效率。

AIO

异步非阻塞，由操作系统完成后回调通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AIOServer {
  public static void main(String[] args) throws Exception {
    final AsynchronousServerSocketChannel serverChannel =
        AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000));

    serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
      @Override
      public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
        try {
          System.out.println("2--"+Thread.currentThread().getName());
          // 再此接收客户端连接，如果不写这行代码后面的客户端连接连不上服务端
          serverChannel.accept(attachment, this);
          System.out.println(socketChannel.getRemoteAddress());
          ByteBuffer buffer = ByteBuffer.allocate(1024);
          socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer buffer) {
              System.out.println("3--"+Thread.currentThread().getName());
              buffer.flip();
              System.out.println(new String(buffer.array(), 0, result));
              socketChannel.write(ByteBuffer.wrap("HelloClient".getBytes()));
            }

            @Override
            public void failed(Throwable exc, ByteBuffer buffer) {
              exc.printStackTrace();
            }
          });
        } catch (IOException e) {
          e.printStackTrace();
        }
      }

      @Override
      public void failed(Throwable exc, Object attachment) {
        exc.printStackTrace();
      }
    });

    System.out.println("1--"+Thread.currentThread().getName());
    Thread.sleep(Integer.MAX_VALUE);
  }
}

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;

public class AIOClient {
    public static void main(String... args) throws Exception {
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 9000)).get();
        socketChannel.write(ByteBuffer.wrap("HelloServer".getBytes()));
        ByteBuffer buffer = ByteBuffer.allocate(512);
        Integer len = socketChannel.read(buffer).get();
        if (len != -1) {
            System.out.println("客户端收到信息：" + new String(buffer.array(), 0, len));
        }
    }
}

总结

同步阻塞 客户端连接，服务端一个专有线程处理，一个线程只能处理一个客户端连接。
BIO是同步阻塞 客户端请求连接，服务端启用一个线程等待客户端传输数据，直至客户端关闭连接。

同步非阻塞 客户端连接，服务端就一个专有线程处理，服务端线程可以处理多个客户端连接。
NIO是同步非阻塞 客户端请求连接，服务端将客户端Socket注册到selector上（线程不会阻塞，等待客户端传输数据）。当客户端向服务端传输数据完成后，服务端主动获取客户端传输的数据。

异步非阻塞 客户端连接，服务端就异步启线程处理任务。
AIO是异步非阻塞 每当客户端连接，服务端就会异步启动线程进行处理连接。

想找工作的狗蛋儿
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java三种IO模型原理实例详解
08-19
"Java三种IO模型原理实例详解" Java中的IO模型可以分为三种：BIO（同步阻塞）、NIO（同步非阻塞）和AIO（异步非阻塞）。每种模型都有其特点和应用场景。 BIO（同步阻塞） BIO是最古老的IO模型，在JDK1.4之前都是...
javaIO模型1
08-08
Java IO模型1主要涉及到的是Java在处理网络数据交互时的不同方式。这里有五种主要的IO模型，它们分别是阻塞IO（BIO）、非阻塞IO、IO多路复用、信号量和异步IO（AIO）。理解这些模型的关键在于区分同步与异步以及阻塞...
Java网络编程——I/O模型
weixin_62017112的博客
07-14 764
目录第一部分：I/O模型简介1. I/O 模型简单的理解2. Java 共支持 3 种网络编程模型/IO 模式3.阻塞与非阻塞4.同步和异步第二部分：BIO（同步并阻塞）1.BIO的理解2.BIO工作机制3.举个小例子4.BIO问题分析 5.DEMO 1.BIO执行流程：2.客户端（Client）3.服务端（Server）第三部分：NIO（同步非阻塞）1.NIO的理解小插曲：多路复用器1.了解Selector2.使用Selector的好处 2.工作机制3.举个小例子 4.DEMO1. NIO执行流程2.客户
java原理4：java的io网络模型
weixin_43930865的博客
02-24 365
当数据准备好后，将数据从内核空间拷贝到用户空间，完成IO函数的调用。当应用程序调用一个 IO 函数，其底层会委托操作系统的recvfrom()去完成，当数据还没有准备好时，revfrom会一直阻塞，等待数据准备好。内核开始复制数据，它会将数据从内核缓冲区复制到用户缓冲区（用户空间的内存），然后内核返回结果（例如返回复制到的用户缓冲区的字节数）。Redis网络模型是采用I/O多路复用器，对key的处理是单线程 避免了多线程之间的竞争，省去了线程切换带来的时间和空间上的性能开销，而且也不会导致死锁的问题。
用java带你了解网络IO模型
qq_26751319的博客
05-22 1919
使用java带你了解BIO,NIO,AIO,什么是多路复用，什么是select/poll/epoll，用最简单的图解让你去深入理解IO模型
java IO模型详解
2401_83707780的博客
04-28 1091
阻塞 vs 非阻塞：这两个概念描述了程序在等待 I/O 操作完成时的状态。阻塞意味着等待，非阻塞意味着在等待过程中能够执行其他任务。同步 vs 异步：这两个概念描述了 I/O 操作的执行方式。同步操作中，I/O 请求和处理是连续的过程，而在异步操作中，I/O 请求和处理是分离的。在现代编程实践中，选择适当的 I/O 模型对于优化性能、资源利用和用户体验至关重要。例如，高性能的服务器和应用通常采用异步非阻塞 I/O 模型来处理大量并发的客户端请求。
Java IO模型
kyrielx的博客
08-28 455
详细介绍Java中支持的三种网络编程模型：BIO、NIO、AIO
JavaNIO浅析IO模型Java开发Java经验技巧共1
11-22
与传统的IO模型相比，NIO具有非阻塞、多路复用等优点，尤其适用于高并发、低延迟的网络应用。本文将深入浅出地探讨Java NIO的基本概念、主要组件以及它如何改进了传统的IO模型。 一、Java NIO概述 在Java传统的IO...
IO模型介绍,理解java常见的IO模型
最新发布
07-02
随着互联网的发展，网络通信的需求日益增长，传统的IO模型已经无法满足高性能、高并发的应用需求。为了应对这一挑战，Java提供了多种IO模型，包括BIO（Blocking IO）、NIO（Non-blocking IO）和AIO（Asynchronous IO...
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
Java 网络IO编程是 Java 编程语言中最重要的知识点之一，涉及到网络编程的各种技术和模型。本篇文章主要介绍了 Java 网络IO编程总结，包括 BIO、NIO 和 AIO 三种模型，并提供了完整的实例代码。 BIO（Blocking I/O...
java网络编程—IO及相关原理(上下文切换\多路复用\Reactor\epoll)
张硕的博客
10-19 3212
相关文章 java网络编程—NIO与Netty(四) java网络编程—NIO与Netty(三) java网络编程—NIO与Netty(二) java网络编程—NIO与Netty(一) java网络编程—基石：五种IO模型及原理(多路复用\epoll) 理解Netty首先要理解NIO，理解NIO首先要理解reactor模型、多路复用select\poll\epoll等等原理。所以
Java常见的三种IO模型
m0_46517444的博客
07-20 1639
java中三种常见的IO模型： 1.BIO BIO属于同步阻塞IO模型 同步阻塞IO模型中，应用程序发起read调用后，会一直阻塞，直到在内核把数据拷贝到用户空间中。数据的读取写⼊必须阻塞在⼀个线程内等待其完成 2.NIO Java 中的 NIO 于 Java 1.4 中引入，对应 java.nio 包，提供了 Channel , Selector，Buffer 等抽象。NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。它支持面向缓冲的，基于通道的 I/O 操作方法。 对于高负载、
面试|JAVA的网络IO模型彻底讲解
大数据星球-浪尖
03-16 571
JAVA的网络IO模型彻底讲解1，最原始的BIO模型该模型的整体思路是有一个独立的Acceptor线程负责监听客户端的链接，它接收到客户端链接请求之后为每个客户端创建一个...
五种网络io模型
热门推荐
倦鸟归时
02-04 1万+
由于最近再看nginx，其采用了优于apache的select网络io模型，所以稍微了解了下网络io的模型的基础知识。 首先，介绍几种常见的I/O模型及其区别，如下： blocking I/O nonblocking I/O I/O multiplexing (select and poll) signal driven I/O (SIGIO)
JAVA五种IO模型
weixin_44579258的博客
06-03 1万+
网络中获取数据的读操作步骤： 同步与异步： 同步与异步是针对应用程序与内核的交互而言。也就是上图的read操作，从缓存中读取数据，如果缓存中换没有准备好，如果是同步操作，它会一直等待，知道操作完成，如果是异步操作，那么他会去做别的事情，等待数据准备好，内核通知它，它再去读取数据 同步过程中进程触发IO操作并等待或者轮询的去查看IO操作是否完成。 异步过程中进程触发IO操作以后，直接返回，做自己的...
简单理解几种Java IO模型
格子的博客
08-09 9969
很多朋友在学习NIO的时候感觉比较吃力，对里面一些概念不是很明朗，本文杜撰了一个大嘴开饭店的故事，来类比Java IO模型的演变，帮助理解几种模型的功能和特点，IO分为磁盘IO和网络IO，本文讨论的都是网络IO。 爪哇村的大嘴做得一手好菜，原本是和平饭店的厨子，对吃的东西悟性很高，工作之余喜欢研究各种创新菜，最近自创一道麻辣小龙虾，顾客们吃后反响强烈，于是，大嘴想自立门户，专门开店经营小龙虾。 ......
Java NIO 系列教程
09-07 159
Java NIO(New IO)是一个可以替代标准Java IO API的IO API（从Java 1.4开始)，Java NIO提供了与标准IO不同的IO工作方式。 Java NIO: Channels and Buffers（通道和缓冲区） 标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲
java网络编程基础--Linux网络IO模型
qq_36697880的博客
08-28 210
一、同步与异步、阻塞与非阻塞 1.1、同步和异步 同步和异步关注的是结果消息的通信机制 首先来解释同步和异步的概念，这两个概念与消息的通知机制有关。也就是同步与异步主要是从消息通知机制角度来说的。 同步:同步的意思就是调用方需要主动等待结果的返回，这个过程才能结束 异步:异步的意思就是不需要主动等待结果的返回，而是通过其他手段比如，状态通知，回调函数等。 1.1.1、概念描述 所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠.
io密集型和cpu密集型_通过实例理解Java网络IO模型
weixin_39915815的博客
11-24 681
来自：51CTO博客(作者：nxlhero)原文链接：https://blog.51cto.com/nxlhero/2442628网络IO模型里有多个概念比较难理解，本文通过用Java实现一个简单的redis，从最简单的单线程单连接到NIO与netty，介绍不同的IO模型。网络IO模型及分类网络IO模型是一个经常被提到的问题，不同的书或者博客说法可能都不一样，所以没必要死抠字眼，关键在于...
java io模型面试题
10-17
Java中的IO模型主要分为同步阻塞IO、同步非阻塞IO、多路复用IO和异步IO四种。其中，同步阻塞IO是最常见的一种，也是最简单的一种。在同步阻塞IO中，当一个线程调用read()或write()时，该线程会被阻塞，直到有数据可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值