同步阻塞BIO与同步非阻塞NIO

最新推荐文章于 2023-03-06 13:38:41 发布
最新推荐文章于 2023-03-06 13:38:41 发布
阅读量232 收藏
点赞数
分类专栏： JavaSE 文章标签： NIO BIO
本文深入探讨了BIO（阻塞I/O）和NIO（非阻塞I/O）的工作原理，通过对比分析，揭示了它们在处理大量并发连接时的优缺点。通过具体的代码示例，展示了BIO每连接每线程模型和NIO多路复用模型的实现，以及它们在实际场景中的性能表现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//模拟服务器端
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;

public class BioServer {

    public static AtomicInteger counter = new AtomicInteger(0);
    public static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket();
            ss.bind(new InetSocketAddress("localhost", 8888));
            while (true) {
                Socket s = ss.accept();  //阻塞点，等待客户端连接
                processWithNewThread(s);  //为每一个客户端创建一个线程
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

   public static void processWithNewThread(Socket s) {
        //lambada表达式写法
        Runnable run = () -> {
            InetSocketAddress rsa = (InetSocketAddress)s.getRemoteSocketAddress();
            System.out.println(time() + "->" + rsa.getHostName() + ":" + rsa.getPort() + "->" + Thread.currentThread().getId() + ":" + counter.incrementAndGet());
            try {
                String result = readBytes(s.getInputStream());   //阻塞点，等待读/写数据完成
                System.out.println(time() + "->" + result + "->" + Thread.currentThread().getId() + ":" + counter.getAndDecrement());
                s.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        };
        new Thread(run).start();
    }


   public static String readBytes(InputStream is) throws Exception {
        long start = 0;
        int total = 0;
        int count = 0;
        byte[] bytes = new byte[1024];
        //开始读数据的时间
        long begin = System.currentTimeMillis();
        while ((count = is.read(bytes)) > -1) {
            if (start < 1) {
                //第一次读到数据的时间
                start = System.currentTimeMillis();
            }
            total += count;
        }
        //读完数据的时间
        long end = System.currentTimeMillis();
        return "wait=" + (start - begin) + "ms,read=" + (end - start) + "ms,total=" + total + "bs";
    }

   public static String time() {
        return sdf.format(new Date());
    }
}
传统BIO

这是一个经典的每连接每线程的模型，之所以使用多线程，主要原因在于socket.accept()、socket.read()、socket.write()三个主要函数都是同步阻塞的，当一个连接在处理I/O的时候，系统是阻塞的，如果是单线程的话必然就挂死在那里；但CPU是被释放出来的，开启多线程，就可以让CPU去处理更多的事情。其实这也是所有使用多线程的本质：

  • 利用多核。
  • 当I/O阻塞系统，但CPU空闲的时候，可以利用多线程使用CPU资源。

现在的多线程一般都使用线程池，可以让线程的创建和回收成本相对较低。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的I/O并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。

不过，这个模型最本质的问题在于，严重依赖于线程。但线程是很"贵"的资源，主要表现在：

  1. 线程的创建和销毁成本很高，在Linux这样的操作系统中，线程本质上就是一个进程。创建和销毁都是重量级的系统函数。
  2. 线程本身占用较大内存，像Java的线程栈，一般至少分配512K～1M的空间，如果系统中的线程数过千，恐怕整个JVM的内存都会被吃掉一半。
  3. 线程的切换成本是很高的。操作系统发生线程切换的时候，需要保留线程的上下文，然后执行系统调用。如果线程数过高，可能执行线程切换的时间甚至会大于线程执行的时间，这时候带来的表现往往是系统load偏高、CPU sy使用率特别高（超过20%以上)，导致系统几乎陷入不可用的状态。
  4. 容易造成锯齿状的系统负载。因为系统负载是用活动线程数或CPU核心数，一旦线程数量高但外部网络环境不是很稳定，就很容易造成大量请求的结果同时返回，激活大量阻塞线程从而使系统负载压力过大。
//模拟客户端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Random;

public class Client {

    public static void main(String[] args) {
        try {
            for (int i = 0; i < 20; i++) {
                Socket s = new Socket();
                s.connect(new InetSocketAddress("localhost", 8888));
                processWithNewThread(s, i);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static void processWithNewThread(Socket s, int i) {
        Runnable run = () -> {
            try {
                //睡眠随机的5-10秒，模拟数据尚未就绪(阻塞等待)
                Thread.sleep((new Random().nextInt(6) + 5) * 1000);
                //写1M数据，为了拉长服务器端读数据的过程
                s.getOutputStream().write(prepareBytes());
                //睡眠1秒，让服务器端把数据读完
                //Thread.sleep(1000);  相当于模拟数据量大的情况下->可能要等1s
                s.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        };
        new Thread(run).start();
    }

    //模拟写1M数据
    static byte[] prepareBytes() {
        byte[] bytes = new byte[1024*1024];   //1048576bs
        //byte[] bytes = new byte[1024*1024*100];   //104857600bs
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = 1;
        }
        return bytes;
    }
}

BIO的运行结果：

20:00:15->127.0.0.1:50374->10:1
20:00:15->127.0.0.1:50383->18:3
20:00:15->127.0.0.1:50385->20:2
20:00:15->127.0.0.1:50377->12:4
20:00:15->127.0.0.1:50379->14:5
20:00:15->127.0.0.1:50381->16:6
20:00:15->127.0.0.1:50393->28:7
20:00:15->127.0.0.1:50391->26:8
20:00:15->127.0.0.1:50389->24:9
20:00:15->127.0.0.1:50387->22:10
20:00:15->127.0.0.1:50376->11:11
20:00:15->127.0.0.1:50378->13:12
20:00:15->127.0.0.1:50380->15:13
20:00:15->127.0.0.1:50382->17:14
20:00:15->127.0.0.1:50384->19:15
20:00:15->127.0.0.1:50386->21:16
20:00:15->127.0.0.1:50388->23:17
20:00:15->127.0.0.1:50390->25:18
20:00:15->127.0.0.1:50392->27:19
20:00:15->127.0.0.1:50394->29:20
20:00:21->wait=5014ms,read=1062ms,total=1048576bs->21:20
20:00:21->wait=5017ms,read=1059ms,total=1048576bs->25:19
20:00:22->wait=5965ms,read=1014ms,total=1048576bs->11:18
20:00:22->wait=5985ms,read=1012ms,total=1048576bs->19:17
20:00:23->wait=6978ms,read=1044ms,total=1048576bs->24:16
20:00:23->wait=6979ms,read=1046ms,total=1048576bs->28:15
20:00:23->wait=6979ms,read=1046ms,total=1048576bs->26:14
20:00:23->wait=6990ms,read=1042ms,total=1048576bs->13:13
20:00:23->wait=6988ms,read=1042ms,total=1048576bs->15:12
20:00:23->wait=6998ms,read=1034ms,total=1048576bs->17:11
20:00:23->wait=6998ms,read=1033ms,total=1048576bs->29:10
20:00:24->wait=7988ms,read=1024ms,total=1048576bs->18:9
20:00:24->wait=7974ms,read=1039ms,total=1048576bs->12:8
20:00:24->wait=7996ms,read=1015ms,total=1048576bs->27:7
20:00:25->wait=8974ms,read=1044ms,total=1048576bs->10:6
20:00:25->wait=8976ms,read=1042ms,total=1048576bs->16:5
20:00:25->wait=8990ms,read=1027ms,total=1048576bs->22:4
20:00:25->wait=8981ms,read=1039ms,total=1048576bs->20:3
20:00:26->wait=9973ms,read=1021ms,total=1048576bs->14:2
20:00:26->wait=9988ms,read=1008ms,total=1048576bs->23:1
NIO

NIO（Non-blocking I/O，也称为New I/O），是一种同步非阻塞的I/O模型，也是I/O多路复用的基础，已经被越来越多地应用到大型应用服务器，成为解决高并发与大量连接、I/O处理问题的有效方式。
NIO一个重要的特点是：socket主要的读、写、注册和接收函数，在等待就绪阶段都是非阻塞的。

//等待时间几乎为0，而服务器端的线程数明显下降，节约资源
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.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

public class NioServer {

    static int clientCount = 0;
    static AtomicInteger counter = new AtomicInteger(0);
    static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
	/**
     * 两种感兴趣的操作共用一个选择器，且选择器运行在主线程里，Worker(读取数据)线程是新的线程。
     * @param args
     */
    public static void main(String[] args) {
        try {
            Selector selector = Selector.open();
            ServerSocketChannel ssc = ServerSocketChannel.open();
            ssc.configureBlocking(false);  //设置非阻塞方式
            ssc.register(selector, SelectionKey.OP_ACCEPT); //注册客户端(连接)事件
            ssc.bind(new InetSocketAddress("localhost", 8888));  //(绑定)
            while (true) {
                selector.select();
                Set<SelectionKey> keys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = keys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();
                    if (key.isAcceptable()) {
                        ServerSocketChannel ssc1 = (ServerSocketChannel)key.channel();
                        SocketChannel sc = null;
                        while ((sc = ssc1.accept()) != null) {
                            sc.configureBlocking(false);
                            sc.register(selector, SelectionKey.OP_READ);
                            InetSocketAddress rsa = (InetSocketAddress)sc.socket().getRemoteSocketAddress();
                            System.out.println(time() + "->" + rsa.getHostName() + ":" + rsa.getPort() + "->" + Thread.currentThread().getId() + ":" + (++clientCount));
                        }
                    } else if (key.isReadable()) {
                        //先将“读”从感兴趣操作移出，待把数据从通道中读完后，再把“读”添加到感兴趣操作中
                        //否则，该通道会一直被选出来
                        key.interestOps(key.interestOps() & (~ SelectionKey.OP_READ));
                        processWithNewThread((SocketChannel)key.channel(), key);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void processWithNewThread(SocketChannel sc, SelectionKey key) {
        Runnable run = () -> {
            counter.incrementAndGet();
            try {
                String result = readBytes(sc);
                //把“读”加进去
                key.interestOps(key.interestOps() | SelectionKey.OP_READ);
                System.out.println(time() + "->" + result + "->" + Thread.currentThread().getId() + ":" + counter.get());
                sc.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            counter.decrementAndGet();
        };
        new Thread(run).start();
    }

    static String readBytes(SocketChannel sc) throws Exception {
        long start = 0;
        int total = 0;
        int count = 0;
        ByteBuffer bb = ByteBuffer.allocate(1024);
        //开始读数据的时间
        long begin = System.currentTimeMillis();
        while ((count = sc.read(bb)) > -1) {
            if (start < 1) {
                //第一次读到数据的时间
                start = System.currentTimeMillis();
            }
            total += count;
            bb.clear();
        }
        //读完数据的时间
        long end = System.currentTimeMillis();
        return "wait=" + (start - begin) + "ms,read=" + (end - start) + "ms,total=" + total + "bs";
    }

    static String time() {
        return sdf.format(new Date());
    }
}

NIO效果：

20:07:21->wait=2ms,read=1113ms,total=1048576bs->11:5
20:07:22->wait=3ms,read=1039ms,total=1048576bs->13:5
20:07:22->wait=38ms,read=1099ms,total=1048576bs->12:7
20:07:22->wait=0ms,read=1016ms,total=1048576bs->16:7
20:07:22->wait=0ms,read=1025ms,total=1048576bs->14:5
20:07:22->wait=11ms,read=1087ms,total=1048576bs->17:4
20:07:23->wait=11ms,read=1073ms,total=1048576bs->19:7
20:07:23->wait=0ms,read=1049ms,total=1048576bs->18:6
20:07:23->wait=0ms,read=1106ms,total=1048576bs->20:5
20:07:24->wait=1ms,read=1011ms,total=1048576bs->22:4
20:07:24->wait=0ms,read=1037ms,total=1048576bs->21:4
20:07:24->wait=0ms,read=1025ms,total=1048576bs->23:3
20:07:24->wait=0ms,read=1030ms,total=1048576bs->24:2
20:07:25->wait=0ms,read=1005ms,total=1048576bs->25:1

它的大致处理过程如下：

1、定义一个选择器，Selector。

相当于设立一个跑腿服务员。

2、定义一个服务器端套接字通道，ServerSocketChannel，并配置为非阻塞的。

相等于聘请了一位大堂经理。

3、将套接字通道注册到选择器上，并把感兴趣的操作设置为OP_ACCEPT。

相当于大堂经理给跑腿服务员说，帮我盯着门外(轮训)，有客人来了告诉我。

4、进入死循环，选择器不时的进行选择。

相当于跑腿服务员一遍又一遍的去询问、去转悠。

5、选择器终于选择出了通道，发现通道是需要Acceptable的。

相当于跑腿服务员终于发现门外来客人了，客人是需要接待的。

6、于是服务器端套接字接受了这个通道，开始处理。

相当于跑腿服务员把大堂经理叫来了，大堂经理开始着手接待。

7、把新接受的通道配置为非阻塞的，并把它也注册到了选择器上，该通道感兴趣的操作为OP_READ。

相当于大堂经理把客人带到座位上，给了客人菜单，并又把客人委托给跑腿服务员，说客人接下来肯定是要点餐的，你不时的来问问。

8、选择器继续不时的进行选择着。

相当于跑腿服务员继续不时的询问着、转悠着。

9、选择器终于又选择出了通道，这次发现通道是需要Readable的。

相当于跑腿服务员终于发现了一桌客人有了需求，是需要点餐的。

10、把这个通道交给了一个新的工作线程去处理。

相当于跑腿服务员叫来了点餐服务员，点餐服务员开始为客人写菜单。

11、这个工作线程处理完后，就被回收了，可以再去处理其它通道。

相当于点餐服务员写好菜单后，就走了，可以再去为其他客人写菜单。

12、选择器继续着重复的选择工作，不知道什么时候是个头。

相当于跑腿服务员继续着重复的询问、转悠，不知道未来在何方。

相信你已经看出来了，大堂经理相当于服务器端套接字，跑腿服务员相当于选择器，点餐服务员相当于Worker线程。

  • BIO是阻塞IO，可以是同步阻塞，也可以是异步阻塞。

  • 第一种是阻塞IO，阻塞点有两个，等待数据就绪的过程和读取数据的过程。

  • 第二种是阻塞IO，阻塞点有一个，读取数据的过程。

  1. 只有一个线程，接受一个连接，读取数据，处理业务，写回结果，再接受下一个连接，这是同步阻塞。这种用法几乎没有。

  2. 一个线程和一个线程池，线程接受到连接后，把它丢给线程池中的线程，再接受下一个连接，这是异步阻塞。对应示例一。

  3. 一个线程和一个线程池，线程运行selector，执行select操作，把就绪的连接拿出来丢给线程池中的线程，再执行下一次的select操作，就是多路复用，这是异步阻塞。对应示例二。

NIO高级主题
  • Proactor与Reactor

  1. 标准/典型的Reactor：
    步骤1：等待事件到来（Reactor负责）。
    步骤2：将读就绪事件分发给用户定义的处理器（Reactor负责）。
    步骤3：读数据（用户处理器负责）。
    步骤4：处理数据（用户处理器负责）。

  2. 改进实现的模拟Proactor：
    步骤1：等待事件到来（Proactor负责）。
    步骤2：得到读就绪事件，执行读数据（现在由Proactor负责）。
    步骤3：将读完成事件分发给用户处理器（Proactor负责）。
    步骤4：处理数据（用户处理器负责）。

对于不提供异步I/O API的操作系统来说，这种办法可以隐藏Socket API的交互细节，从而对外暴露一个完整的异步接口。借此，我们就可以进一步构建完全可移植的，平台无关的，有通用对外接口的解决方案。

  • Buffer的选择
    通常情况下，操作系统的一次写操作分为两步：
  1. 将数据从用户空间拷贝到系统空间。
  2. 从系统空间往网卡写。

同理，读操作也分为两步：

  1. 将数据从网卡拷贝到系统空间；
  2. 将数据从系统空间拷贝到用户空间。

对于NIO来说，缓存的使用可以使用DirectByteBuffer和HeapByteBuffer。如果使用了DirectByteBuffer，一般来说可以减少一次系统空间到用户空间的拷贝。但Buffer创建和销毁的成本更高，更不宜维护，通常会用内存池来提高性能。

如果数据量比较小的中小应用情况下，可以考虑使用heapBuffer；反之可以用directBuffer。

NIO存在的问题

使用NIO != 高性能，当连接数<1000，并发程度不高或者局域网环境下NIO并没有显著的性能优势。

NIO并没有完全屏蔽平台差异，它仍然是基于各个操作系统的I/O系统实现的，差异仍然存在。使用NIO做网络编程构建事件驱动模型并不容易，陷阱重重。

推荐使用成熟的NIO框架，如Netty，MINA等。解决了很多NIO的陷阱，并屏蔽了操作系统的差异，有较好的性能和编程模型。

NIO的同步，异步，阻塞和非阻塞理解
dw147258dw的专栏
05-18 1175
“阻塞”与"非阻塞"与"同步"与“异步"不能简单的从字面理解，提供一个从分布式系统角度的回答。1.同步与异步同步和异步关注的是消息通信机制(synchronous communication/ asynchronous communication) 所谓同步，就是在发出一个*调用*时，在没有得到结果之前，该*调用*就不返回。但是一旦调用返回，就得到返回值了。 换句话说，就是由*调用者*主动等待这个*调用*的结果。 而异步则是相反，*调用*在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个.
非阻塞IO(NIO)
征客
08-14 958
也称作同步阻塞IO。
深度讲解：同步/异步/阻塞/非阻塞/BIO/NIO/AIO
01-19
常规的误区 　　假设有一个展示用户详情的需求，分两步，先调用一个HTTP接口拿到详情数据，然后使用适合的视图展示详情数据。 　　如果网速很慢，代码发起一个HTTP请求后，就卡住不动了，直到十几秒后才拿到HTTP响应，然后继续往下执行。 　　这个时候你问别人，刚刚代码发起的这个请求是不是一个同步请求，对方一定回答是。这是对的，它确实是。 　　但你要问它为什么是呢?对方一定是这样回答的，“因为发起请求后，代码就卡住不动了，直到拿到响应后才可以继续往下执行”。 　　我相信很多人也都是这样认为的，其实这是不对的，是把因果关系搞反了： 　　不是因为代码卡住不动了才叫同步请求，而是因为它是同步
BIO/NIO/同步/异步/阻塞/非阻塞
hulinku的博客
10-07 544
在高性能的IO体系设计中，有几个名词概念常常会使我们感到迷惑不解。具体如下：&amp;amp;amp;nbsp; 序号 问题 1 什么是同步？ 2 什么是异步？ 3 什么是阻塞？ 4 什么是非阻塞？ 5 什么是同步阻塞？ 6 什么是同步非阻塞？ 7 什么是异步阻塞？ 8 什么是异步非阻塞？ 散仙不才，在查了一部分资料后，愿试着以通俗易懂的方式解释下这几个名词。如...
（一） BIO，NIO， 阻塞，非阻塞，你懂了吗
apooahe3423的博客
07-20 301
一般来说，一个输入操作通常包括两个阶段： 1、等待数据准备好； 2、从内核向进程复制数据 是否同步的判断依据是： 是否 针对的 整个过程，即2个阶段，是否有阻塞 是否阻塞的判断依据是： 按 程序等待消息通知时的状态角度来说的，，即针对第一阶段来说 例子很形象： https://my.oschina.net/u/1859679/blog/183916...
阻塞IO和非阻塞IO的区别 (BIO&NIO)
trees19990807的博客
11-04 3174
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
详解 同步异步、阻塞非阻塞 与 BIO NIO AIO区别、多路复用
Java技术攻略的博客
03-06 504
BIO（同步阻塞）：你到饭馆点餐，然后在那等着，啥都干不了，餐没做好，你就必须等着！NIO（同步非阻塞）：你在饭馆点完餐，就去玩儿了。不过玩一会儿，就回饭馆问一声：好了没？AIO（异步非阻塞）：饭馆打电话说，我们知道您的位置，一会给你送过来，安心玩儿就可以了，类似于外卖。哪种方式更有效率呢？是不是一目了然呢？BIO：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
Java IO模型详解：同步阻塞、非阻塞及异步IO的应用与优化
最新发布
03-28
内容概要：本文详细介绍了Java IO模型的基本概念及其分类，重点讲解了同步阻塞IO (BIO)、非阻塞IO (NIO) 和异步IO (AIO) 的特点和应用场景。首先解释了什么是I/O以及它在计算机结构中的角色，接着探讨了应用程序视角...
同步/异步/阻塞/非阻塞/BIO/NIO/AIO一文全搞懂(结合现实例子)
小王博客基地
09-27 538
一、常规的误区 假设有一个展示用户详情的需求，分两步，先调用一个HTTP接口拿到详情数据，然后使用适合的视图展示详情数据。 如果网速很慢，代码发起一个HTTP请求后，就卡住不动了，直到十几秒后才拿到HTTP响应，然后继续往下执行。 这个时候你问别人，刚刚代码发起的这个请求是不是一个同步请求，对方一定回答是。这是对的，它确实是。 但你要问它为什么是呢？对方一定是这样回答的，“因为发起请求后，代码就卡住不动了，直到拿到响应后才可以继续往下执行”。 我相信很多人也都是这样认为的，其实这是不对的，是把因果关系搞反了
对于同步和非同步，阻塞和非阻塞，BIO，NIO的概念的回顾
只作为个人备忘录
06-11 446
同步和异步 同步和异步其实是指CPU时间片的利用，主要看请求发起方对消息结果的获取是主动发起的，还是被动通知的，如下图所示。如果是请求方主动发起的，一直在等待应答结果（同步阻塞），或者可以先去处理其他事情，但要不断轮询查看发起的请求是否有应答结果（同步非阻塞），因为不管如何都要发起方主动获取消息结果，所以形式上还是同步操作。如果是由服务方通知的，也就是请求方发出请求后，要么一直等待通知（异步阻塞），要么先去干自己的事（异步非阻塞）。当事情处理完成后，服务方会主动通知请求方，它的请求已经完成，这就是异步。异
BIO与NIO、AIO的区别
IT界的一只菜鸟
09-29 1739
IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。 一、BIO 在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或者遭到拒绝请求，如果有的...
关于BIO同步阻塞,NIO同步非阻塞,AIO异步非阻塞,多路复用
FREEDOM
06-16 970
前言 使用异步，非阻塞。是为了减少线程的开销（因为正常情况下一个IO如一个socket客户端的连接，server需要单独开一个线程，传统的socket是同步阻塞的） （1）同步/异步 ：内核缓冲区 向用户缓冲区 态写数据的过程，如果这个过程 中， 用户线程不阻塞就是异步，阻塞就是同步。 （2）阻塞/非阻塞 ： 用户线程 是否一直等待内核缓冲区有数据，有数据才会返回的为阻塞。不管有没有数据都返回的叫做非阻塞。 1.1. JavaIO读写原理 无论是Socket的读写还是文件的读写，在Ja....
NIO详解（二）： BIO 浅谈 同步 异步与阻塞 非阻塞
Master-TJ的个人博客
11-07 6319
在我们了解Java NIO/BIO的网络通信之前，我们先了解一下常用的阻塞/非阻塞模型以及同步/异步的概念 一、阻塞和非阻塞 从简单的开始，我们以经典的读取文件的模型举例。（对操作系统而言，所有的输入输出设备都被抽象成文件。）在发起读取文件的请求时，应用层会调用系统内核的I/O接口。 如果应用层调用的是阻塞型I/O，那么在调用之后，应用层即刻被挂起，一直出于等待数据返回的状态，直到系统内核从...
BIO、NIO、AIO，同步、异步、阻塞、非阻塞的概念
每天迈出一小步!
11-18 388
同步异步、阻塞非阻塞 同步 ： 自己亲自出马持银行卡到银行取钱（使用同步IO时，Java自己处理IO读写）； 异步 ： 委托一小弟拿银行卡到银行取钱，然后给你（使用异步IO时，Java将IO读写委托给OS处理，需要将数据缓冲区地址和大小传给OS(银行卡和密码)，OS需要支持异步IO操作API）； 阻塞 ： ATM排队取款，你只能等待（使用阻塞IO时，Java调用会一直阻塞到读写完成才返回）； 非阻塞 ： 柜台取款，取个号，然后坐在椅子上做其它事，等号广播会通知你办理，没到号你就不能去，你可以不断问大堂经理排
BIO（同步阻塞IO）,NIO(同步非阻塞IO),AIO（异步非阻塞IO）——>（同步与异步、阻塞与非阻塞）
rootkiss的博客
08-31 918
熟练掌握 BIO,NIO,AIO 的基本概念以及一些常见问题是你准备面试的过程中不可或缺的一部分，另外这些知识点也是你学习 Netty 的基础。 BIO,NIO,AIO 总结 1. BIO (Blocking I/O) 1.1 传统 BIO 1.2 伪异步 IO 1.3 代码示例 1.4 总结 2. NIO (New I/O) 2.1 NIO 简介 2.2 NIO的特性/NIO与IO...
聊聊Java BIO（同步阻塞IO）、NIO（非阻塞IO）、AIO（异步IO）
绕行的专栏
02-25 1091
Java中有阻塞IO、非阻塞IO。阻塞IO可以理解为“一个连接对应于一线程”。非阻塞IO可以理解为“一个请求（一个请求里面可能会有多个连接【长连接短连接】）对应于一线程”。 BIO Java中BIO也成为同步阻塞IO。 同步阻塞IO模式下，服务器实现模式为一个连接对应一个线程，即：有连接请求从客户端发起时，服务器端就需要创建一个线程进行处理，如果有大量连接时，服务器就需要创建大量线程进行处理。当然...
BIO（同步阻塞）、NIO（同步非阻塞）、AIO（异步非阻塞）、IO多路复用
weixin_43751710的博客
08-07 465
看到一个讲的很详细的BIO、NIO https://blog.youkuaiyun.com/u010310183/article/details/81700405 BIO和NIO是两种不同的网络通信模型，现如今NIO已经大量应用在Jetty、ZooKeeper、Netty等开源框架中。 “术语”： “read”是将内核的数据读到socket中，然后发给客户端； 准备数据是指数据被 “select” 到内核中。...
Java NIO 深入剖析：阻塞与非阻塞，同步与异步
文档详细对比了BIO与NIO的差异，并阐述了阻塞与非阻塞、同步与异步的IO模型。" NIO（Non-blocking Input/Output），即非阻塞输入/输出，是Java中用于提高I/O效率的一种机制。传统的IO模型，如BIO（Blocking IO），...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值