BIO和NIO

已于 2023-04-28 09:24:23 修改
阅读量170 收藏 1
点赞数
文章标签： nio java 服务器
于 2023-04-20 21:45:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45018911/article/details/130276473
版权

BIO和NIO

  • BIO：同步阻塞式IO，服务器使用一个线程处理一个请求，当客服端有请求到达时就启动一个线程进行处理，直到请求结束才会释放这个线程，如果这个请求什么也不做就会一直占用该线程，当有很多这样的请求就会消耗大量的资源。
  • NIO：同步非阻塞式IO，多个请求注册到多路复用器（Selector）上，共用一个线程进行处理，多路复用器会轮询每个请求，当有事件发生时才会通知主线程进行处理。
    在这里插入图片描述

Socket与SocketChannel

Socket

  • Socket与ServerSocket是JDK提供的两个用于实现TCP程序的类
  • ServerSocket表示服务器端，socket表示的是客户端。通信时，服务器端要创建ServerSocket对象，对本机的指定端口进行监听；客户端创建Socket向指定IP地址的端口号发起连接请求，连接后就可以进行通信。

代码示例

public static void main(String[] args) throws IOException, InterruptedException {
        final ServerSocket serverSocket=new ServerSocket(8080);
        //服务端线程
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        Socket socket=serverSocket.accept();
                        System.out.println("连接成功");
                        System.out.println("开始接收数据...");
                        InputStream inputStream=socket.getInputStream();
                        inputStream.read();
                        System.out.println("数据接收完毕...");
                    }

                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        System.out.println("thread:"+thread.getState());
        thread.start();
        //客户端线程
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Socket socket=new Socket(InetAddress.getLocalHost(),8080);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        System.out.println("thread:"+thread.getState());
        thread1.start();
        System.out.println("thread:"+thread.getState());
    }

输出

thread:NEW
thread:RUNNABLE
thread:RUNNABLE
连接成功
开始接收数据…

分别建立了两个线程用于模拟客户端与服务端，线程创建完成处于NEW状态，调用start()方法以后变成Runnable状态。从输出可以看出服务端线程启动以后，serverSocket.accept方法后面的语句并没有执行，而是在客户端线程启动以后才开始输出;而在执行了inputStream.read方法后，后面的语句也没有执行，这是因为客户端并没有向服务端输入。
显然这是因为Socket是阻塞式的，使用这些方法都会等待对方做出响应以后程序才会继续执行。

I/O阻塞时线程的状态

在这里还有一个问题，为什么线程已经阻塞了，但是使用getState方法查看线程的状态时却仍然是Runnable呢？
这就要区分JVM层面线程的状态和操作系统层面线程的状态了，这两着有些差异，而上面提到的阻塞指的是操作系统层面的线程阻塞。

JVM线程的状态

JVM中线程的状态有六种，分别是：

NEW（初始状态）
RUNNABLE（运行状态）
BLOCKED（阻塞状态）
WATTING（等待状态）
TIMED_WAITING（限时等待状态）
TERMINATED（终止状态）

线程的状态转换关系
在这里插入图片描述

其中BLOCKED、WATTING和TIMED_WAITING都会使线程进入休眠状态，将这三种归为一类，线程的生命周期可以简化为
在这里插入图片描述

操作系统的线程状态

操作系统的状态可分为

初始状态
可运行状态
运行状态
休眠状态
终止状态

在这里插入图片描述

前面说到的阻塞指的操作系统层面上的阻塞，也就是说线程在操作系统上处于休眠状态，可为什么JVM中仍然是Runnable状态呢，因为使用JVM获取到的线程状态实际上指的是线程在JVM中的状态，线程可能在操作系统上被阻塞了，但是在JVM的角度来看这个线程仍然在运行。
JVM线程状态的改变通常只于自身显式引入的机制有关，比如显式调用wait()、sleep()等方法。而操作系统层面的线程阻塞并不会改变线程在JVM中的状态。

SocketChannel

  • Socket与ServerSocket是两个通信的端点，Socket的方法都是阻塞的，属于BIO通信；SocketChannel与ServSocketChannel分别是客户端与服务端的通道，SocketChannel提供configureBlocking方法，来描述通道的阻塞状态。我们可以将SocketChannel设置为非阻塞状态。
  • 两者关系：虽然每个SocketChannel通道都有一个关联的Socket对象，但并非所有socket都有一个关联的SocketChannel。如果我们使用传统的方式来new Socket，那么其不会有关联的SocketChannel。
  • 阻塞方法与非阻塞的方法对比
  1. 输入操作
    • 进程A调用阻塞socket.read方法时，若该socket的接收缓冲区没有数据可读，则该进程A被阻塞，操作系统将进程A睡眠，直到有数据到达；
    • 进程A调用非阻塞SocketChannel.read方法时，若该SocketChannel的接收缓冲区没有数据可读，则进程A收到一个EWOULDBLOCK错误提示，表示无可读数据，read方法立即返回。
  2. 输出操作
    • 进程A调用阻塞socket.write方法时，若该socket的发送缓冲区没有多余空间，则进程A被阻塞，操作系统将进程A睡眠，直到有空间为止；
    • 进程A调用非阻塞SocketChannel.write方法时，若该SocketChannel的发送缓冲区没有多余空间，则进程A收到一个EWOULDBLOCK错误提示，表示无多余空间，write方法立即返回。
  3. 连接操作
    • 对于阻塞型的socket而言，调用socket.connect方法创建连接时，会有一个三次握手的过程，每次需要等到三次握手完成之后（ESTABLISHED 状态），connect方法才会返回，这意味着其调用进程需要至少阻塞一个RTT时间。
    • 对于非阻塞的SocketChannel而言，调用connect方法创建连接时，当三次握手可以立即建立时（一般发生在客户端和服务端在一个主机上时），connect方法会立即返回；而对于握手需要阻塞RTT时间的，非阻塞的SocketChannel.connect方法也能照常发起连接，同时会立即返回一个EINPROGRESS（在处理中的错误）。

代码示例

public static void main(String[] args) throws IOException, InterruptedException {
        final ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        serverSocketChannel.configureBlocking(false);
        System.out.println("服务启动...");
        System.out.println("开始监听端口号8080...");
        final Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    SocketChannel socketChannel=serverSocketChannel.accept();
                    System.out.println("连接成功...");
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread.start();
        Thread.currentThread().sleep(2000);
        System.out.println("主线程休眠2s等待服务端准备就绪...");
        System.out.println("客户端启动...");
        //客户端
        final SocketChannel socketChannel=SocketChannel.open();
        socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(),8080));
        System.out.println("客户端发起连接...");
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                String data="Hello, here is a piece of information, please pay attention to check!";
                try {
                    socketChannel.write(ByteBuffer.wrap(data.getBytes()));
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread1.start();
    }

输出

服务启动…
开始监听端口号8080…
连接成功…
主线程休眠2s等待服务端准备就绪…
客户端启动…
客户端发起连接…

主线程中启动两个线程进行分别模拟服务端和客户端，将ServerSocketChannel设置为非阻塞状态，通过程序可以看到，执行serverSocketChannel.accept方法非没有使程序发生阻塞，而是直接输出了“连接成功…”。

多路复用器Selector

Selector选择器的概述和作用

SocketChannel经常与多路复用器Selector放在一起使用。
概述: Selector被称为：选择器，也被称为：多路复用器，可以把多个Channel注册到一个Selector选择器上, 那么就可以实现利用一个线程来处理这多个Channel上发生的事件，并且能够根据事件情况决定Channel读写。这样，通过一个线程管理多个Channel，就可以处理大量网络连接了, 减少系统负担, 提高效率。因为线程之间的切换对操作系统来说代价是很高的，并且每个线程也会占用一定的系统资源。所以，对系统来说使用的线程越少越好。

作用: 一个Selector可以监听多个Channel发生的事件, 减少系统负担 , 提高程序执行效率 。
在这里插入图片描述

代码示例

public class SocketChannelTest {
    //定义任务的处理类，对SocketChannel做出处理
    private static  class ServerHandler implements Runnable{
        SocketChannel socketChannel;
        ServerHandler(SocketChannel socketChannel){
            System.out.println("开始处理READ事件...");
            this.socketChannel=socketChannel;
        }
        @Override
        public void run() {
            try {
                ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
                int len=socketChannel.read(byteBuffer);
                System.out.println("读到字节数："+len);
                byteBuffer.flip();
                while(byteBuffer.hasRemaining()) {
                    System.out.print((char)byteBuffer.get());
                }
                byteBuffer.clear();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    public static void main(String[] args) throws IOException, InterruptedException {
        //创建一个线程池用于处理SocketChannel的任务
        final ExecutorService executorService= Executors.newFixedThreadPool(5);
        //服务端：将serverSocketChannel的ACCEPT事件注册到selector中
        //在监听到ACCEPT事件后再将SocketChannel的READ事件注册到selector中
        //在监听到READ事件后启动一个任务放到线程池中进行处理
        final ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        final Selector selector=Selector.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务启动...");
        System.out.println("开始监听端口号8080...");
        final Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while(true){
                        selector.select();
                        Set<SelectionKey> selectionKeys=selector.selectedKeys();
                        for(SelectionKey selectionKey:selectionKeys) {
                            selectionKeys.remove(selectionKey);
                            if (selectionKey.isAcceptable()){
                                SocketChannel socketChannel=serverSocketChannel.accept();
                                System.out.println("连接成功...");
                                String clientInfo=socketChannel.socket().getInetAddress().getHostAddress();
                                int port=socketChannel.socket().getPort();
                                System.out.println("客户端信息为"+clientInfo+":"+port);
                                socketChannel.configureBlocking(false);
                                socketChannel.register(selector,SelectionKey.OP_READ);
                                System.out.println("开始监听READ事件...");
                            }else if(selectionKey.isReadable()){
                                System.out.println("监听到READ事件...");
                                executorService.submit(new ServerHandler((SocketChannel) selectionKey.channel()));
                                selectionKey.cancel();
                            }
                        }
                    }

                } catch (IOException e) {
                    throw new RuntimeException(e);
                }

            }
        });
        thread.start();
        System.out.println("主线程休眠2s等待服务端准备就绪...");
        Thread.currentThread().sleep(2000);
        System.out.println("客户端启动...");
        //客户端
        final SocketChannel socketChannel=SocketChannel.open();
        socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(),8080));
        System.out.println("客户端发起连接...");
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                String data="Hello, here is a piece of information, please pay attention to check!";
                try {
                    socketChannel.write(ByteBuffer.wrap(data.getBytes()));
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread1.start();
    }
}

输出：

服务启动…
开始监听端口号8080…
主线程休眠2s等待服务端准备就绪…
客户端启动…
客户端发起连接…
连接成功…
客户端信息为172.19.32.1:59251
开始监听READ事件…
监听到READ事件…
开始处理READ事件…
读到字节数：69
Hello, here is a piece of information, please pay attention to check!

同样使用两个线程来模拟客户端与服务端，服务端将serverSocketChannel的ACCEPT事件注册到selector中，在监听到ACCEPT事件后再将SocketChannel的READ事件注册到selector中，在监听到READ事件后启动一个自定义的任务ServerHandler放到线程池中进行处理。

Selector选择器使用方法

  • Selector选择器的获取

Selector selector = Selector.open();

  • 注册Channel到Selector

SelectionKey key =channel.register(selector,SelectionKey.OP_READ);
register()方法的第二个参数：是一个int值，意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件，而且可以使用SelectionKey的四个常量表示：
连接就绪–常量：SelectionKey.OP_CONNECT
接收就绪–常量：SelectionKey.OP_ACCEPT (ServerSocketChannel在注册时只能使用此项)
读就绪–常量：SelectionKey.OP_READ
写就绪–常量：SelectionKey.OP_WRITE
注意：对于ServerSocketChannel在注册时，只能使用OP_ACCEPT，否则抛出异常。

一点小情绪
关注
网络编程-BIO和NIO的理解
Tiger的专栏
09-28 766
1.BIO和NIO简介 BIO：同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善； NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送连接请求都会注册到多路复用器上，多路复用器轮训到连接有I/O请求时才启动一个线程进行处理； AIO（NIO.2）:异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器
Java BIO和NIO详解
weixin_44715427的博客
03-29 997
I/O模型 Java BIO ​ 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器就需要启动一个线程处理 ​ 如果这个连接不做任何事情就会造成不必要的浪费 Java NIO ​ 同步非阻塞，服务器实现模式为一个线程处理多个请求，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询连接到有I/O请求就进行处理 Java AIO 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的有效请求都是由OS先完成了再通知服务器应用去启动线程处理，一般适用于连接数较多且连接时间
BIO和NIO详解
热门推荐
漫天雪_昆仑巅
03-04 3万+
到底什么是“IO Block” 很多人说BIO不好，会“block”，但到底什么是IO的Block呢？考虑下面两种情况： 用系统调用read从socket里读取一段数据 用系统调用read从一个磁盘文件读取一段数据到内存 如果你的直觉告诉你，这两种都算“Block”，那么很遗憾，你的理解与Linux不同。Linux认为： 对于第一种情况，算作block，因为Linux无法知道网络上对方...
BIO和NIO、AIO的区别
Flying_Fish_roe的博客
09-07 647
特点BIO（阻塞 I/O）NIO（非阻塞 I/O）AIO（异步 I/O）操作方式同步阻塞同步非阻塞异步非阻塞线程模型每连接一个线程少量线程处理大量连接极少量线程处理大量连接编程难度简单中等高系统资源消耗高适中低适用场景小规模并发场景高并发场景极高并发和长连接场景优点简单易用非阻塞、高并发真正异步、性能高缺点线程数目多，性能差编程复杂实现复杂，跨平台支持不一。
BIO和NIO的区别
炸酱面的博客
02-18 2万+
1.BIO基本介绍 BIO是传统的Java IO编程，其基本的类和接口在java.io包中 BIO(blocking I/O)：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 BIO方式使用于连接数目比较小且固定的架构，这种服务方式对服务器资源要求比价高，并且局限于应用中，JDK1.4以前的唯一选择，程序简单易理解 BIO基本模型： 2.NIO基本介绍 NIO全称 java non-blocking
对于BIO和NIO的理解
EDG_Clearlove_7的博客
01-12 1016
对于NIO和BIO的形象理解和循序渐进的逻辑引导，select，poll和epoll系统调用详解
Java BIO 和 NIO 使用，有什么区别
u013749113的博客
05-16 944
BIO 和 NIO 之间的最大区别在于阻塞和非阻塞。BIO 是阻塞式的 I/O 模型，而 NIO 是非阻塞式的 I/O 模型。BIO 通常是单线程的，一个连接需要一个线程来处理，如果连接数量很大，那么就需要创建很多线程，这样会导致系统的资源消耗过大。而 NIO 利用了选择器的概念，可以使用一个线程处理多个连接，从而提高系统的并发能力。另外，NIO 还引入了缓冲区（Buffer）的概念，可以提高读写操作的效率。
Tomcat中BIO和NIO的区别（Tomcat）
qq_43253125的博客
09-21 1039
8.阻塞读取数据流的时候，还是得利用Selector，因为刚开始的时候socketChannel会被设置成非阻塞,然后socketChannel会被注册到一个Selector（称为主Selector），然后你如果再想把他改成阻塞，是会报错的（NIO中的限制），tomcat中为了实现这个阻塞，又构造了一个辅助Selector，将socketChannel重新注册到辅助Selector上，并设置成阻塞（在此之前已经取消了对主Selector的绑定）一旦轮询到对应的事件，就会解锁，解阻塞。
BIO和NIO消耗的cpu和内存比较
sinat_14913533的博客
08-27 1031
这个其实是遇到的一道面试题，其题目描述也很简单，BIO和NIO消耗的cpu和内存哪个比较大。因为确实从来没遇到过去从这个角度去比较NIO和BIO的，所以我尝试变结实原来，边分析，但是整个过程对方三次认为我跑题了，强调回到他问题的本身，先给出答案，所以整个过程其实并没有真的深入去分析。但我觉得这个问题有点意思，就记录一下，从我掌握的知识来分析一下。..............................
Java使用BIO和NIO进行文件操作对比代码示例
08-19
"Java使用BIO和NIO进行文件操作对比代码示例" Java BIO和NIO是两种不同的输入/输出（IO）模型，在文件操作中发挥着重要作用。BIO（Blocking I/O）是一种同步阻塞IO模式，而NIO（Non-Blocking I/O）是一种同步非阻塞...
UNION ALL函数用法
最新发布
猫敷雪
10-14 593
UNION ALL用于将两个或多个SELECT查询的结果集合并在一起。与UNION不同，UNION ALL不会去除重复的记录。这意味着即使结果集中有相同的行，它们也会被保留。语法UNION ALL示例employees和，我们想要获取所有员工和承包商的名字。UNION ALL这条查询将返回employees表和表中所有名字的组合，包括重复的名字。
【编程进阶知识】Java NIO：掌握高效的I/O多路复用技术
Dylaniou的博客
10-11 880
Java NIO提供了非阻塞的I/O操作，这对于处理高并发的网络应用至关重要。它隐藏了操作系统级别的细节，使得开发者可以更加专注于业务逻辑的实现。通过本文，你已经了解了Java NIO中的Selector如何实现高效的I/O多路复用。使用Selector，你可以构建高性能的网络应用，同时处理多个客户端连接。与传统的select/epoll相比，Java NIO提供了更加高级和面向对象的解决方案。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1442
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 915
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 654
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JavaSE——认识异常
wx2023_10_15的博客
10-12 941
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
springboot 用request.setAttribute 传值到控制层
qq56477643的博客
10-09 598
【代码】springboot 用request.setAttribute 传值到控制层。
栈和队列、IO流分类 BIO和NIO、AIO的区别
05-19
栈和队列： 栈（Stack）和队列（Queue）...AIO（Asynchronous IO）是一种基于事件驱动的IO模型，它不同于BIO和NIO的轮询方式，而是通过回调函数的方式来实现异步处理。AIO模型适合于大量的并发连接，可以提高IO效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值