简述 BIO 、NIO 模型

已于 2024-05-07 09:33:29 修改
阅读量1k 收藏 14
点赞数 14
文章标签： nio
于 2024-05-06 17:36:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38217393/article/details/138497892
版权
  • BIO : 同步阻塞I/O（Block IO）

         服务器实现模式为每一个连接一个线程，即客户端有连接请求时服务器就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，此处可以通过线程池机制进行优化。

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * 多人聊天室 - 服务端
 */
public class BioServer {
    static List<Socket> clientList = new ArrayList<>();

    public static void main(String[] args) throws Exception {

        int port = 8080;

        ServerSocket serverSocket = new ServerSocket(port);

        while (true) {
            Socket client = serverSocket.accept();

            System.out.println("客户端: " + client.getPort() + " 连接成功!");

            clientList.add(client);

            forwardProcess(client);
        }
    }

    /**
     * 转发处理
     */
    public static void forwardProcess(Socket socket) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    forwardMsg(socket);
                }
            }
        }).start();
    }

    /**
     * 转发消息
     */
    public static void forwardMsg(Socket socket) {

        try {
            String msg = readMsg(socket);

            System.out.println(msg);

            for (Socket client : clientList) {
                if (client != socket) {
                    writeMsg(client, msg);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    /**
     * 写入消息
     */
    public static void writeMsg(Socket socket, String msg) throws IOException {
        PrintStream ps = new PrintStream(socket.getOutputStream());
        ps.println(msg);
        ps.flush();
    }

    /**
     * 读取消息
     */
    public static String readMsg(Socket socket) throws IOException {
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String msg;
        if ((msg = br.readLine()) != null) {
            msg = socket.getPort() + " 说: " + msg;
        }
        return msg;
    }

}

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class BilClient {

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

        String ip = "127.0.0.1";
        int port = 8080;

        Socket client = new Socket(ip, port);

        readProcess(client);

        OutputStream os = client.getOutputStream();
        PrintStream ps = new PrintStream(os);
        Scanner scanner = new Scanner(System.in);
        while (true) {
            String input = scanner.nextLine();
            ps.println(input);
            ps.flush();
        }
    }

    /**
     * 读取处理
     */
    public static void readProcess(Socket socket) {
        new Thread(() -> {
            while (true) {
                try {
                    System.out.println(readMsg(socket));
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();
    }

    /**
     * 读取消息
     */
    public static String readMsg(Socket socket) throws IOException {
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String msg;
        if ((msg = br.readLine()) != null) {
        }
        return msg;
    }
}

  • ​NIO: 同步非阻塞式IO，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求会被注册到多路复用器上，多路复用器轮询到有 I/O 请求就会进行处理。
  • Channel，翻译过来就是“通道”，就是数据传输的管道，类似于“流”，但是与“流”又有着区别。
    • 既可以从Channel中读取数据，又可以写数据到Channel，但流的读写通常是单向的——输入输出流
    • 通道可以异步读写
    • 通道中的数据总是先读取到buffer（缓冲区），或者总是需要从一个buffer写入，不能直接访问数据
    • 非阻塞特性：Channel在设计上采用了非阻塞的特性，它不会像传统的流一样在读写操作上阻塞线程，而是立即返回结果，告诉调用者当前的状态。这使得程序可以在等待数据准备的过程中同时进行其他操作，实现了非阻塞IO。
    • 事件通知机制：Channel通常搭配选择器（Selector）来使用，选择器能够检测多个Channel的就绪状态，如是否可读、可写等，并通过事件通知（例如轮询或回调）及时地通知程序哪些Channel处于就绪状态，从而可以进行相应的读写操作。这种机制支持程序实现异步IO模型。
    • 操作系统底层支持：Channel的异步读写也依赖于操作系统底层的异步IO支持。Java NIO中的Channel实际上是对操作系统底层异步IO的封装和抽象，利用了操作系统提供的异步IO机制来实现其自身的异步读写功能。
  • Buffer是一个对象，里面是要写入或者读出的数据，在java.nio库中，所有的数据都是用缓冲区处理的。
    • 在读取数据时，它是直接读到缓冲区中的；在写入数据时，也是直接写到缓冲区中，任何时候访问Channel中的数据，都是通过缓冲区进行操作的。
    • 缓冲区实质上是一个数组，通常是一个字节数组ByteBuffer，当然也有其他类型的：
  • Selector被称为选择器，Selector会不断地轮询注册在其上的Channel，如果某个Channel上发生读或写事件，这个Channel就被判定处于就绪状态，会被Selector轮询出来，然后通过SelectionKey可以获取到就绪Channel的集合，进行后续的I/O操作。
    • 一个多路复用器Selector可以同时轮询多个Channel，JDK使用了epoll()代替了传统的select实现，所以并没有最大连接句柄的限制，这意味着只需要一个线程负责Selector的轮询，就可以接入成千上万的客户端。


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.Charset;
import java.util.Set;

/**
 * NIO 聊天室 服务端
 */
public class NioServer {

    private Integer port;

    ByteBuffer readBuffer = ByteBuffer.allocate(1024);

    ByteBuffer writerBuffer = ByteBuffer.allocate(1024);

    private Charset charset = Charset.forName("UTF-8");

    public NioServer(Integer port) {
        this.port = port;
    }

    public static void main(String[] args) {
        NioServer nioServer = new NioServer(8080);
        nioServer.start();
    }

    private void start() {

        try {

            // 开启socket
            ServerSocketChannel server = ServerSocketChannel.open();

            // 设置非阻塞
            server.configureBlocking(false);

            // 绑定端口
            server.socket().bind(new InetSocketAddress(port));

            // 开启通道, 得到 Selector (选择器)
            Selector selector = Selector.open();

            //  注册 selector 监听事件
            server.register(selector, SelectionKey.OP_ACCEPT);

            System.out.println("启动服务器， 监听端口：" + port + "...");

            while (true) {

                // 阻塞监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入 集合内部并返回事件数量
                selector.select();

                // 返回存有SelectionKey的集合
                Set<SelectionKey> selectionKeys = selector.selectedKeys();

                for (SelectionKey selectionKey : selectionKeys) {
                    handle(selectionKey, selector);
                }

                //  处理后清理 selectionKeys
                selectionKeys.clear();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    /**
     * 事件处理
     */
    private void handle(SelectionKey key, Selector selector) throws IOException {

        //  SelectionKey 常用方法
        //isAcceptable()	是否是连接继续事件
        //isConnectable()	是否是连接就绪事件
        //isReadable()	是否是读就绪事件
        //isWritable()	是否是写就绪事件

        // SelectionKey 常用事件
        //SelectionKey.OP_ACCEPT	接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
        //SelectionKey.OP_CONNECT	连接就绪事件，表示客户端与服务器的连接已经建立成功
        //SelectionKey.OP_READ	读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了（通道目前有数据，可以进行读操作了）
        //SelectionKey.OP_WRITE	写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）

        //处理连接
        if (key.isAcceptable()) {
            ServerSocketChannel server = (ServerSocketChannel) key.channel();

            SocketChannel client = server.accept();
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ);
            System.out.println(client.socket().getPort() + " 已建立连接 ...");
        }
        //  读取消息
        else if (key.isReadable()) {

            SocketChannel client = (SocketChannel) key.channel();

            String msg = client.socket().getPort() + " 说: " + readMsg(client);

            System.out.println(msg);

            forwardMsg(msg, client, selector);

        }
    }

    /**
     * 读取通道消息
     */
    private String readMsg(SocketChannel client) throws IOException {
        readBuffer.clear();
        while (client.read(readBuffer) > 0) ;
        readBuffer.flip();
        return String.valueOf(charset.decode(readBuffer));
    }

    /**
     * 转发
     */
    private void forwardMsg(String msg, SocketChannel client, Selector selector) throws IOException {
        for (SelectionKey key : selector.keys()) {
            Channel connectedClient = key.channel();
            if (connectedClient instanceof ServerSocketChannel) {
                continue;
            }

            if (key.isValid() && !client.equals(connectedClient)) {
                writerBuffer.clear();
                writerBuffer.put(charset.encode(msg));
                writerBuffer.flip();
                while (writerBuffer.hasRemaining())
                    ((SocketChannel) connectedClient).write(writerBuffer);
            }
        }
    }
}


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.SocketChannel;
import java.nio.charset.Charset;
import java.util.Scanner;
import java.util.Set;

/**
 * NIO 聊天室 客户端
 */
public class NioClient {

    private String ip;

    private Integer port;

    private ByteBuffer writerBuffer = ByteBuffer.allocate(1024);

    private ByteBuffer readBuffer = ByteBuffer.allocate(1024);

    private Charset charset = Charset.forName("UTF-8");

    public NioClient(String ip, Integer port) {
        this.ip = ip;
        this.port = port;
    }

    public static void main(String[] args) {
        NioClient nioClient = new NioClient("127.0.0.1", 8080);
        nioClient.start();
    }


    public void start() {

        try {

            // 开启通道
            SocketChannel client = SocketChannel.open();

            // 设置非阻塞
            client.configureBlocking(false);

            Selector selector = Selector.open();
            client.register(selector, SelectionKey.OP_CONNECT);
            client.connect(new InetSocketAddress(ip, port));

            while (true) {
                selector.select();

                Set<SelectionKey> selectionKeys = selector.selectedKeys();

                for (SelectionKey selectionKey : selectionKeys) {
                    handle(selectionKey, selector);
                }

                selectionKeys.clear();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private void handle(SelectionKey key, Selector selector) throws IOException {
        // 处理连接事件
        if (key.isConnectable()) {

            SocketChannel client = (SocketChannel) key.channel();

            if (client.isConnectionPending()) {
                client.finishConnect();

                // 处理用户输入
                new Thread(() -> {
                    Scanner scanner = new Scanner(System.in);
                    while (true) {
                        String msg = scanner.nextLine();

                        writerBuffer.clear();
                        writerBuffer.put(charset.encode(msg));
                        writerBuffer.flip();

                        while (writerBuffer.hasRemaining()) {
                            try {
                                client.write(writerBuffer);
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        }

                    }
                }).start();

            }
            client.register(selector, SelectionKey.OP_READ);
        }
        // 读取消息信息
        else if (key.isReadable()) {

            SocketChannel client = (SocketChannel) key.channel();

            String s = readMsg(client);
            System.out.println(s);

        }
    }

    private String readMsg(SocketChannel client) throws IOException {
        readBuffer.clear();
        while (client.read(readBuffer) > 0) ;
        readBuffer.flip();
        return String.valueOf(charset.decode(readBuffer));
    }
}

拜了佛冷
关注
【netty】BIO通讯模型
九师兄
01-09 673
才用BIO通讯模型的服务器，通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端连接请求后为每个客户端创建一个新的线程进行链路处理，处理完成后，通过输出流返回应答给客户端，线程销毁，这就是典型的已请求一应答通讯模型。下面做个测试代码，做的是maven项目 pom.xml<?xml version="1.0" encoding="UTF-8"?> <project xmlns="
Java后端面试高频问题：BIO、NIO、AIO的区别？
weixin_70730532的博客
07-07 4416
①BIO（blocking IO）阻塞IO，即在读写数据的过程中会发生阻塞现象。当用户线程发出IO请求之后，内核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞状态，用户线程交出CPU。当数据就绪之后，操作系统就会将数据从内核空间拷贝到用户空间，并返回结果给用户线程，用户线程才解除阻塞状态。（因为我们的用户程序只能获取用户空间的内存，无法直接获取内核空间的内存）典型的阻塞IO模型的例子为：data = socket.read();如果数据没有就绪，就会一直阻塞在read方法。 ②N
BIO通信模型图
maguanghui_2012的专栏
01-18 1092
Netty权威指南》第2章NIO入门，本章中，我们会分别对JDK的BIO、NIO和JDK1.7最新提供的NIO2.0的使用进行详细说明，通过流程图和代码讲解，让大家体会到随着Java I/O类库的不断发展和改进，基于Java的网络编程会变得越来越简单，随着异步I/O功能的增强，基于Java NIO开发的网络服务器甚至不逊色于采用C++开发的网络程序。本节为大家介绍BIO通信模型图。 AD：5
Java BIO、NIO(通信/群聊系统、零拷贝)、AIO
日常记录
01-09 883
BIO适用于连接数较少的场景，NIO适用于中等并发场景，而AIO适用于高并发的异步操作场景，如网络服务器、文件传输等。选择适当的I/O模型取决于应用程序的性能和并发需求。
Java中的BIO通信模型
程铭程铭你快成名的博客
08-10 7768
在上一篇Linux和Java中的I/O模型中介绍了NIO、BIO模型，本篇文章讲解一下多线程+BIO的通信模型。主流的web服务器Tomcat就是多线程+BIO的通信模型的代表者。 原理图 Server端 Server端即接收消息的那一端。BIO是一种阻塞IO，也就是说，当前线程会一直阻塞，直到接受到消息。所以通常会使用多个线程来配合，即每来一个IO连接，都新启一个线程去处理。 但由于在Java中，线程是一种比较宝贵的资源，所以一般会使用线程池来复用线程资源。 public class Server {
BIO模型
Super_Powerbank的博客
12-03 1021
文章目录1、BIO简介2、BIO代码服务端客户端3、BIO+多线程服务端客户端 1、BIO简介 BIO：同步阻塞模型，在java jdk 1.4之前网络编程采用的就是BIO 需要服务端先创建并启动serverSocket，客户端启动socket实例来连接connect服务端，服务端这是需要使用accept来鉴定客户端的连接，一旦连接上就可以进行双向通信 实现echo命令 客户端发送一个消息，服务端将消息返回给客户端，可以多次接收客户端的消息连接 2、BIO代码 服务端 public class Ser
IO系列(八) -浅析NIO工作原理
最新发布
程序员志哥的博客
05-20 1253
现在使用 NIO 的场景越来越多，很多网上的技术框架或多或少的使用 NIO 技术，譬如 Tomcat、Jetty、Netty，学习和掌握 NIO 技术已经不是一个 Java 攻城狮的加分技能，而是一个必备技能。
从NIO到NETTY简述.pptx（培训）
03-20
本篇文章将从OSI七层模型、TCP与UDP的异同点、BIO、NIO、AIO的简述以及Netty的基本使用等方面展开讨论。 首先，理解网络通信的基础——OSI七层模型是至关重要的。OSI模型是国际标准化组织提出的一种通信参考模型，...
NIO知识概括
weixin_41005188的博客
09-17 733
NIO知识概括同步和异步阻塞和非阻塞 同步和异步 所谓同步，就是在发出一个"调用"时，在没有得到结果之前，该“调用”就不返回。但是一旦调用返回，就得到返回值了。换句话说，就是由“调用者”主动等待这个“调用”的结果。 而异步则是相反，"调用"在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在"调用"发出后，"被调用者"通过状态、通知来通知调用者，或通过回调函数处理这个调用。 同步（synchronous）就是协同步调，按预定的先后次序进行运
杂谈 : 聊一聊NIO
weixin_57907028的博客
07-27 235
一 . 前言 NIO 是老生常谈了 , 由于最近准备开 Netty 的新坑了 , 不再局限于使用 , 初期先把前置的知识点回顾一下 二 . NIO 的概念 2.1 NIO 是什么 ? NIO 可以从2个维度说 ,它既可以是一种设计模型 ,也可以说是 Java 中的一个包 (NIO 包是在 java1.4中引入的). IO 是计算机与其他部分之间的接口 , IO 可以分为多种 : BIO ,NIO , AIO NIO 模型 2.2 NIO , AIO , BIO 的区别 BIO : 基于流
浅谈(Java)BIO通信
程序员乌拉的博客！
04-30 1585
BIO就是: blocking IO。最容易理解、最容易实现的IO工作方式，应用程序向操作系统请求网络IO操作，这时应用程序会一直等待；另一方面，操作系统收到请求后，也会等待，直到网络上有数据传到监听端口；操作系统在收集数据后，会把数据发送给应用程序；最后应用程序受到数据，并解除等待状态。
BIO，NIO和AIO是Java网络编程的三种模型学习教程
liuyaokai1990的博客
09-21 460
BIO，NIO和AIO是Java网络编程的三种模型 BIO：同步并阻塞，服务实现模式为一个连接对应一个线程，即客户端发送一个连接，服务端要有一个线程来处理。如果连接多了，线程数量不够，就只能等待，即会发生阻塞。 NIO：同步非阻塞，服务实现模式是一个线程可以处理多个连接，即客户端发送的连接都会注册到多路复用器上，然后进行轮询连接，有I/O请求就处理 AIO：异步非阻塞，引入了异步通道，采用的是proactor模式，特点是：有效的请求才启动线程，先有操作系统完成在通知服务端
BIO、NIO、AIO 介绍和适用场景分析
2401_84046895的博客
04-14 1226
机会是留给有准备的人，大家在求职之前应该要明确自己的态度，熟悉求职流程，做好充分的准备，把一些可预见的事情做好。对于应届毕业生来说，校招更适合你们，因为绝大部分都不会有工作经验，企业也不会有工作经验的需求。同时，你也不需要伪造高大上的实战经验，以此让自己的简历能够脱颖而出，反倒会让面试官有所怀疑。你在大学时期应该明确自己的发展方向，如果你在大一就确定你以后想成为Java工程师，那就不要花太多的时间去学习其他的技术语言，高数之类的，不如好好想着如何夯实Java基础。请转发本文支持一下。
从理论到实践：深度解读BIO、NIO、AIO的优缺点及使用场景
weixin_45131680的博客
04-18 1160
BIO适合连接数目较少且固定的架构，NIO适合连接数目多，但是并发读写操作相对较少的场景，AIO则适合连接数目多，且并发读写操作也多的场景。可以发现，AIO和NIO的使用方式基本一致，数据都是从Channel读入Buffer，或者从Buffer写入Channel中，不同的是AIO是实现了异步非阻塞。）， 通过上面代码和运行结果可以发现，在服务端和客户端进行通信时，我们并没有新建线程类进行通信，这也是NIO和BIO最大的区别之一。NIO适合一些复杂的、高频的、长连接的通信场景，例如聊天室、网络游戏等。
Netty学习——基础篇1（同步阻塞IO-BIO） 备份
geminigoth的博客
02-26 819
阻塞I/O模型：最常用的I/O模型就是阻塞I/O模型，缺省情况下，所有文件操作都是阻塞的。以套接字接口为例来讲解此模型：在进程空间中调用recvfrom，其系统调用直到数据包到达且被复制到应用进程的缓冲区或者发生错误时才返回，再次期间一直会等待，进程在从调用recvfrom开始到它返回的整段时间内都是被阻塞的，因此成为阻塞I/O模型模型。如下图所示：非阻塞I/O模型：r。
Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
热门推荐
anxpp的博客
05-29 17万+
本文会从传统的BIO到NIO再到AIO自浅至深介绍，并附上完整的代码讲解。 1、BIO编程 1.1、传统的BIO编程 网络编程的基本模型是C/S模型，即两个进程间的通信。 服务端提供IP和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。 传统的同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
一、BIO、NIO、AIO通信机制理解
Runner的博客
05-10 6867
关于BIO、NIO、AIO通信机制的理解
Spring中BeanDefinitionRegistoryPostProcessor的实现
雾里看花叹朦胧
02-12 250
BeanFactoryPostProcessor用于在BeanFactory实例化完成之后， 再做的增强处理 而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后， 再做的增强处理 实现了BeanFactoryPostProcessor接口的， 要晚于实现了BeanDefinitionRegistryPostProcessor接口...
网络编程之中篇——BIO模型详述
m0_54356563的博客
10-09 1243
1、BIO介绍 1.1、BIO的概念 BIO（Blocking IO）同步阻塞IO模型，在JDK 1.4之前，建立网络链接采用的只有BIO的模型 需要服务端首先启动建立一个ServerSocket实例，然后客户端启动Socket实例对服务端进行连接通信，服务端通过调用accept方法等待接收客户端的连接请求，一旦接收到连接请求，就可以进行读写操作 在BIO编程中，相应的方法会产生阻塞：accept()、read()、write()、connect(),直至相关的操作等待完成之后才能继续后续代..
BIO NIO AIO编程对比及示例源码分析
从描述来看，该资源包含对Java中的阻塞式IO（BIO）、非阻塞式IO（NIO）以及异步IO（AIO）的示例源码，并详细解释了每种IO模型的特点和它们各自适用的场景。此外，压缩包中包含了标准的Maven项目文件"pom.xml"和源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值