分布式专题｜肝了这篇，再也不怕面试官问BIO、NIO、AIO了，我先肝了，你随意

最新推荐文章于 2023-04-20 10:47:09 发布
最新推荐文章于 2023-04-20 10:47:09 发布
阅读量1.8k 收藏
点赞数 31
分类专栏： 技术专栏 文章标签： java netty 分布式 nio epoll
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34311210/article/details/111089399
版权

IO模型指的是在网络数据传输过程中，使用什么通道去发送和接收数据，我们常见的有BIO、NIO、AIO(NIO2.0),我接下来会对这些进行详细的介绍

同步/异步/阻塞/非阻塞 到底是什么意思？

  • 同步/异步
    指的是你去调用一个方法，如果这个方法是同步的，那么你就会等待这个方法执行结束后才能执行后续操作；
    如果是异步的话，他会立即给你返回，但是这个不是真实的结果，真实的结果它是通过消息机制通知你或者回调机制通知你的。

  • 阻塞/非阻塞
    阻塞指的是当你去调用一个获取洗衣机信息方法的时候，如果这个时候没有洗衣机，那么方法就会一直阻塞，直到能查询到洗衣机的信息才会返回结果；
    非阻塞指的是当你调用一个获取洗衣机信息方法的时候，如果当时没有查到信息，你不会一直阻塞在那里，你这时可以去做别的事，但是你会时不时的去检查下是否有结果，然后再阻塞获取下，但是这不会影响你做其它事。

BIO(同步阻塞)

我们经常使用的就是BIO，在我们学习编程基础javaSE的时候，大家应该都会学过socket通信，这里面使用的就是同步阻塞。
我们先看下BIO的模型：

在这里插入图片描述

在BIO模型中，一个连接会对应一个处理线程，如果服务端使用单线程进行处理，后续连接将会一直阻塞；

  • 缺点：
    • 代码中的read操作是阻塞操作，如果连接之后，服务端一直不发送数据，将会一直阻塞当前线程，浪费资源。
    • 如果连接数很多，意味着创建的线程数量就会越来越多，会造成服务器压力太大，后续优化成线程池处理方式，勉强解决了此问题。
  • 应用场景
    BIO适用于连接数较少且固定的架构，这种模式对服务器资源要求较高，但程序复杂度比较低；

代码示例

// 客户端
package com.example.netty.bio;

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

public class SocketClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",9000);
        socket.getOutputStream().write("我是客户端".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服务端发送数据结束");
        byte[] bytes = new byte[1024];
        try {
            int read = socket.getInputStream().read(bytes);
            System.out.println("服务端发送过来的数据为："+new String(bytes,0,read));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {

        }

    }
}
 //服务端
 package com.example.netty.bio;

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

public class SocketServer{
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket=new ServerSocket(9000);
        while (true){
            System.out.println("等待连接");
            // 阻塞等待
            Socket client = serverSocket.accept();
            System.out.println("有客户端连接了");
            handleRead(client);
        }
    }

    /**
     *
     * @param client
     */
    private static void handleRead(Socket client) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                byte[] bytes = new byte[1024];
                try {
                    int read = client.getInputStream().read(bytes);
                    System.out.println("客户端发送过来的数据为："+new String(bytes,0,read));
//                    Thread.sleep(Integer.MAX_VALUE);
                    client.getOutputStream().write("你好，我收到你的数据了".getBytes());
                    client.getOutputStream().flush();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {

                }
            }
        }).start();

    }
}

NIO(同步非阻塞)

NIO在BIO的基础上进行了升级，将阻塞换成非阻塞，虽然只是模式变了下，但是代码复杂量却增加了不少。
在NIO模型中，服务端可以开启一个线程处理多个连接，它是非阻塞的，客户端发送的数据都会注册到多路复用器selector上面，当selector（selector的select方法是阻塞的）轮询到有读、写或者连接请求时，才会转发到后端程序进行处理，没有数据的时候，业务程序并不需要阻塞等待。

NIO有三大组件：Channel(通道)、Buffer（缓存区）、Selector(选择器)

  • Channel
    类似于流，但是它是一个双向的流，他是连接服务端和客户端的通道，不管是客户端还是服务端，都可以使用对通道进行读写数据。
  • Buffer
    它就是一个缓冲区，用来存放数据的载体，它借助通道，在客户端和服务端之间传递数据。
  • Selector
    它对应一个或多个线程，客户端的连接都会注册到selector上面，然后由selector去调用后端处理程序

NIO结构模型

在这里插入图片描述

NIO的非阻塞到底体现在哪里呢？

看模型图大家有可能都知道，客户端所有的连接通道都会注册到selector上面，select会通过轮询去获取这些通道的状态，这些状态有accpet(连接请求)、READ读请求。

如果在轮询过程中发现已经有一个连接请求状态的话，这说明已经有一个客户端想要和服务端进行连接，直接把这个通道传给后端程序去处理连接操作；如果是在BIO模型下的话，会一直阻塞在accept上，直到有连接请求才会释放，继续执行后续的代码。

如果在轮询过程中发现已经有一个读请求状态的话，这说明已经有一个客户端把数据发送给服务端了，服务端可以直接把通道交给后端程序进行读操作的处理；如果是在BIO模型下的话，会一直阻塞的read上，直到有连接请求才会释放，继续执行后续的代码。

以上可以总结为：在NIO模型中，如果服务端执行了read操作的话，就说明已经有可用的数据进行读取了，如果执行了accpet操作的话，就说明此时一定有客户端发起了与服务端的连接，能够保证这种操作的前提是selector轮询到了可读可连接的通道状态。

如果selector轮询后，得到了多个通道的read和accpet状态，NIO是如何处理的？

  • 单线程
    如果在单线程模式下，处理方式是按照轮询后得到的变化的通道的先后顺序进行处理的，没错，它是同步进行处理的，也就是它只能处理完这个通道的操作，才能继续处理下个通道的请求，在selector代码中，是通过遍历所有有变化的通道进行处理的，后面大家看代码就明白了，这种一个selector对应一个线程的模式其实就是redis的单线程IO模型。

  • 多线程
    如果是在多线程模式下，selector在遍历每一个通道的时候，都会把对通道的操作交给一个线程去处理，一般都会丢到线程中去处理，这个时候执行顺序就得看cpu的调度情况来决定了。

接下来我们结合代码来整体看下NIO的工作机制

代码示例

  • 服务端代码
package com.example.netty.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;

public class NioServer {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.socket().bind(new InetSocketAddress(9000));

        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            System.out.println("等待事件发生");
            // 这里还是阻塞等待，
            int select = selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                iterator.remove();
                handleChannel(selectionKey);
            }
        }
    }

    private static void handleChannel(SelectionKey selectionKey) {
        if (selectionKey.isAcceptable()) {
            System.out.println("有客户端发生了连接");
            ServerSocketChannel channel = (ServerSocketChannel) selectionKey.channel();
            try {
                SocketChannel client = channel.accept();
                client.configureBlocking(false);
                // 连接之后立即注册读操作，客户端发送数据过来才能监听到
                client.register(selectionKey.selector(), SelectionKey.OP_READ);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else if (selectionKey.isReadable()) {

            System.out.println("收到客户端发送数据的请求");
            SocketChannel channel = (SocketChannel) selectionKey.channel();

            // 如果这里你不读取数据，读事件会一直触发，这是有NIO属于水平触发决定的，
            ByteBuffer allocate = ByteBuffer.allocate(1024);
            try {
                int read = channel.read(allocate);
                if (read != -1) {
                    System.out.println("客户端发送的数据:" + new String(allocate.array(), 0, read));
                }
                channel.write(ByteBuffer.wrap("你好，我是服务端".getBytes()));
                // 处理完读操作之后，需要重新注册下读操作，
                // 如果下面一行被放开，将会一直会有可写操作触发，因为网络中99.999%的情况下都是可写的，一般不监听
//                selectionKey.interestOps(SelectionKey.OP_WRITE | SelectionKey.OP_READ);
                selectionKey.interestOps(SelectionKey.OP_READ);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else if (selectionKey.isWritable()) {
            System.out.println("触发写事件");
        }
    }
}
  • 服务端架构图

在这里插入图片描述

  • 服务端代码说明

    1. 创建一个 ServerSocketChannel 和 Selector ，并将 ServerSocketChannel 注册到 Selector 上
    2. selector 通过 select() 方法监听 channel 事件，当客户端连接时，selector 监听到连接事件， 获取到 ServerSocketChannel 注册时 绑定的 selectionKey
    3. selectionKey 通过 channel() 方法可以获取绑定的 ServerSocketChannel
    4. ServerSocketChannel 通过 accept() 方法得到 SocketChannel
    5. 将 SocketChannel 注册到 Selector 上，关心 read 事件
    6. 注册后返回一个 SelectionKey, 会和该 SocketChannel 关联
    7. selector 继续通过 select() 方法监听事件，当客户端发送数据给服务端，selector 监听到read事件，获取到 SocketChannel 注册时 绑定的 selectionKey
    8. selectionKey 通过 channel() 方法可以获取绑定的 socketChannel
    9. 将 socketChannel 里的数据读取出来
    10. 用 socketChannel 将服务端数据写回客户端

    大家有可能注意到我在代码注释中提到的水平触发，我这做下解释：水平触发是多路复用中的一种模式，与此对应的还有一个边缘触发。

  • 水平触发

    如果在通道中检测到数据变化后会触发通知，如果收到通知后，事件处理程序没有完全读取缓冲区中的所有数据或压根就没有读，那么在水平触发模式下，就会一直触发这个通知，直到缓冲区的内容被读取完，NIO中select和poll就属于这种模式

  • 边缘触发

    情况同上，不过是当系统通知一次之后，只有当通道中的数据再次发生改变后，才会再次发生通知。epoll既可以采用水平触发,也可以采用边缘触发.

  • 客户端代码

package com.example.netty.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.SocketChannel;
import java.util.Iterator;

public class NioClient {
    private Selector selector;

    public static void main(String[] args) throws IOException {
        NioClient client = new NioClient();
        client.initClient("127.0.0.1", 9000);
        client.connect();
    }

    private void connect() throws IOException {
        while (true) {
            // 阻塞等待
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                iterator.remove();
                handler(selectionKey);
            }
        }
    }

    private void handler(SelectionKey selectionKey) throws IOException {
        // 收到服务端发送的数据
        if (selectionKey.isReadable()) {
            SocketChannel channel = (SocketChannel) selectionKey.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int len = channel.read(buffer);
            if (len != -1) {
                System.out.println("客户端收到信息：" + new String(buffer.array(), 0, len));
            }
        // 连接事件发生
        } else if (selectionKey.isConnectable()) {
            SocketChannel channel = (SocketChannel) selectionKey.channel();
            // 一般发起了连接后，会立即返回，需要使用isConnectionPending判断是否完成连接，如果正在连接，则调用finishConnect，如果不能连接则会抛出异常
            if (channel.isConnectionPending()) {
                channel.finishConnect();
            }
            channel.configureBlocking(false);
            ByteBuffer buffer = ByteBuffer.wrap("你好，我是客户端".getBytes());
            channel.write(buffer);
            selectionKey.interestOps(SelectionKey.OP_READ);
        }
    }

    private void initClient(String s, int i) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        selector = Selector.open();
        socketChannel.connect(new InetSocketAddress(s, i));
        socketChannel.register(selector, SelectionKey.OP_CONNECT);
    }
}

多路复用常见的底层实现api

在这里插入图片描述

poll相比selelct，没有最大连接的限制；
epoll相对于前两者，是一个不一样的机制，基于事件通知的方式，通知调用者；

AIO(异步非阻塞)

异步非阻塞， 由操作系统完成后回调通知服务端程序启动线程去处理， 一般适用于连接数较多且连接时间较长的应用
应用场景： AIO方式适用于连接数目多且连接比较长（重操作） 的架构，JDK7 开始支持

  • AIO代码示例：
    // 服务端代码
    package com.example.netty.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 IOException, InterruptedException {
        final AsynchronousServerSocketChannel serverChannel =
                AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000));
        serverChannel.accept(null,new  CompletionHandler<AsynchronousSocketChannel, Object>() {

            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                serverChannel.accept(attachment, this);
                try {
                    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 attachment) {
                            buffer.flip();
                            System.out.println(new String(buffer.array(), 0, result));
                            socketChannel.write(ByteBuffer.wrap("HelloAioClient".getBytes()));
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {

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

            @Override
            public void failed(Throwable exc, Object attachment) {

            }
        });
        Thread.sleep(Integer.MAX_VALUE);
    }
}

// 客户端代码
package com.example.netty.aio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.util.concurrent.ExecutionException;

public class AioClient {
    public static void main(String[] args) throws ExecutionException, InterruptedException, IOException {
        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));
        }
    }
}

总结：可以看出异步非阻塞模式的代码是非常简单的，所有的操作都是通过回调机制触发的，我们只需要在回调方法中处理我们自己的逻辑就行了，其实AIO是基于NIO进行封装，后面会讲到netty也是基于NIO进行封装的

BIO、NIO、AIO区别

在这里插入图片描述

微信搜一搜【AI码师】关注帅气的我，回复【干货领取】，将会有大量面试资料和架构师必看书籍等你挑选，包括java基础、java并发、微服务、中间件等更多资料等你来取哦。

乐哥聊编程
关注
  • 31
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 28
    评论
专栏目录
bio nio aio demo
04-11
bio nio aio demo下载，可直接运行main方法。了解 bio nio aio基础用法
5分钟思考网络模型：IO、BIO、NIO
笔记小屋
11-02 209
IO IO其实指的是Input/Output，是指输入输出，主要用来传输数据，各个设备之间的数据传输，那么为何慢慢有了很多IO？NIO、BIO、AIO等，这些都是其实现形式，基于不同的操作系统机制来包装的IO模型，我们慢慢就会知道这些模型的区别。 IO流的分类 根据处理数据类型的不同分为：字符流和字节流 根据数据流向不同分为：输入流和输出流 字符流和字节流 字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别： 读写单
关于IO、BIO、NIO的理解
wang_hahah的博客
07-21 1179
IO、BIO、NIO理解 简介 BIO：同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。 NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。 AIO(NIO.2)：异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服
IO，BIO，NIO理解
xiaoaxiao
05-05 1539
BIO，NIO，AIO理解  一、前提基础知识   1.1.同步与异步    关注的是被调用方的执行方式及返回时机。    同步：被调用方做完内部所有事情后再返回，同步调用的调用者一定会得到被调用方的结果。    异步：被调用方先返回，再做事情，做完所有事情后再通知调用方（回调方法），异步调用方不会立即得到被调用方的结果，而是当被调用方执行完成后通过回调函数处理该结果。   1.2.阻塞与非阻塞 ...
NIO深入剖析
weixin_46633487的博客
02-28 1342
第四章 JAVA NIO深入剖析 在讲解利用NIO实现通信架构之前，我们需要先来了解一下NIO的基本特点和使用。 4.1 Java NIO 基本介绍 Java NIO（New IO）也有人称之为 java non-blocking IO是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传
一篇看懂 BIO、NIO、AIO的区别和原理
dayong1q的博客
07-17 706
四种主要的IO模型 一般服务器端编程经常需要构造高性能的IO模型，常见的IO模型有四种： （1）同步阻塞IO（Blocking IO） 阻塞与非阻塞： 阻塞IO，指的是需要内核IO操作完成后，才返回到用户空间，执行用户的操作。阻塞指的是用户空间程序的执行状态，用户空间程序需等到IO操作彻底完成。传统的IO模型都是同步阻塞IO。在java中，默认创建的socket都是阻塞的。 同步与异步： 同步IO，是一种用户空间与内核空间的调用发起方式。同步IO是指用户空间线程是主动发起IO请求的一方，内核空间是被动接受方
2024年Java常见的-BIO,NIO,AIO,Netty面试题
最新发布
04-20
主要是介绍java方面网络方面 网络通信方面的面试题，核心内容主要是关于BIO,NIO,AIO,Netty的面试，算是一套八股文吧，还是老话，该背的还是要背一背！！！
SocketIO-BIO-NIO-AIO.zip
07-16
用Java代码来告诉您什么是BIO, 什么是NIO, 什么是AIO
BIO,NIO,AIO,Netty面试题
02-22
包含BIO、NIO、AIO及Netty等知识点的面试题及答案 适合将要参加Java开发工程师岗位面试的同学，熟悉相关知识点，更好的应对面试
浅谈Java中BIO、NIO和AIO的区别和应用场景
08-26
主要介绍了Java中BIO、NIO和AIO的区别，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
BIO、NIO、AIO详解
song_myth的博客
04-20 977
Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可，这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。
BIO,NIO,AIO原理详解
qq_22162093的博客
07-23 1171
之前对BIO,BIO,AIO原理的了解仅仅限于白问话以及字面上的解释，如同经常看博文讲解的那种去银行排队取号的解释，但是还是发现自己不甚了解，今天从源码层好好学习下这些知识层面。 基本概念： 对于IO我们应该非常熟悉了，IO不仅仅针对文件的操作，网络编程socket的通信，就是IO操作。 输入、输出流（InputStream、OutputStream）用于读取或写入字节，如操作图片、视频等，Reader和Writer 则用于操作字符，增加了字符编码功能。本质上计算机操作都是字节，不管是网络或者文件，Read
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、 的原理及区别与应用场景
IT蜗牛的专栏
03-13 433
同步阻塞IO（JAVA BIO）：BIO【同步阻塞】 在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，其实就是服务端创建一个ServerSocket， 然后就是客户端用一个Socket去连接服务端的那个ServerSocket， ServerSocket接收到了一个的连接请求就创建一个Socket和一个线程去跟那个Socket进行通讯。接着客户端和服务端就进行阻塞式的通信，客户端发送一个请求，服务端Socket进行处理后返回响应，在响应返回前，客户端那边就阻塞等待，什么事情也...
网络IO模型对比（BIO、NIO、AIO）
恒哥的博客
02-09 2036
一文搞懂网络IO模型（BIO、NIO、AIO）
BIO,NIO,AIO原理详解以及代码实现,结果证明
怪物的博客
03-06 1711
一.BIO BIO是java1.4之前唯一的IO逻辑,在客户端通过socket向服务端传输数据,服务端监听端口,由于传统io读数据的时候,如果数据没有传达,IO会一直等待输入传入,所以当有请求过来的时候,新起一条线程对数据进行等待,处理.导致每一个链接都对应着服务器的一个线程. 可以看出,BIO是同步阻塞的 BIO实现代码如下: public class BIO { public...
BIO、NIO、AIO的区别和原理
程序员杂谈
06-29 1045
一、IO模型的知识 JAVA BIO：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程并处理，如果这个连接不做任何事情会造成不必要的开销，当然可以通过线程池机制改善 JAVA NIO：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有IO请求时才启动一个线程进行处理 JAVA AIO(NIO2)：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应
BIO，NIO，AIO分别是什么？他们有什么区别？
qq_45849148的博客
08-30 5761
BIO，NIO，AIO分别是什么？他们有什么区别？
什么是BIO，NIO？他们和多路复用器有啥关系？
Java极客技术
08-28 1194
每天早上七点三十，准时推送干货Photo by Scott Evans on Unsplash阿粉第一次了解到io相关知识是在网上看面经的时候，平时只会写业务代码，面对bio，nio，多...
bio nio aio的区别
07-11
Java中的BIO、NIO和AIO是三种不同的I/O模型。 BIO（Blocking I/O）是阻塞式I/O模型，即在进行I/O操作时，线程会一直阻塞直到操作完成。这种模型适用于连接数较少的情况，但在高并发环境下会导致线程阻塞，资源浪费...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 28
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乐哥聊编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值