JAVA网络编程——BIO、NIO、AIO深度解析

已于 2023-12-07 12:46:59 修改
阅读量1.6k 收藏 25
点赞数
分类专栏： # 网络+并发+函数式+JVM # 计算机网络 JAVA高阶 文章标签： java 网络
于 2023-12-06 19:32:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YYBDESHIJIE/article/details/134838337
版权

I/O 一直是很多Java同学难以理解的一个知识点，这篇帖子将会从底层原理上带你理解I/O，让你看清I/O相关问题的本质。

1、I/O的概念

I/O 的全称是Input/Output。虽常谈及I/O，但想必你也一时不能给出一个完整的定义。搜索了谷哥欠，发现也尽是些冗长的论述。要想厘清I/O这个概念，我们需要从不同的视角去理解它。

1.1、计算机结构的视角

根据冯.诺依曼结构，计算机结构分为 5 大部分：运算器、控制器、存储器、输入设备、输出设备。其中输入是指将数据输入到计算机的设备，比如键盘鼠标；输出是指从计算机中获取数据的设备，比如显示器；以及既是输入又是输出设备，硬盘，网卡等。
在这里插入图片描述
用户通过操作系统才能完成对计算机的操作。计算机启动时，第一个启动的程序是操作系统的内核，它将负责计算机的资源管理和进程的调度。换句话说：操作系统负责从输入设备读取数据并将数据写入到输出设备。

1.2、程序应用的视角

根据大学里学到的操作系统相关的知识：为了保证操作系统的稳定性和安全性，一个进程的地址空间划分为 用户空间（User space） 和 内核空间（Kernel space ） 。

应用程序作为一个文件保存在磁盘中，只有加载到内存到成为一个进程才能运行。应用程序运行在计算机内存中，必然会涉及到数据交换，比如读写磁盘文件，访问数据库，调用远程API等等。但我们编写的程序并不能像操作系统内核一样直接进行I/O操作。

从应用程序的视角来看的话，我们的应用程序对操作系统的内核发起 IO 调用（系统调用），操作系统负责的内核执行具体的 IO 操作。也就是说，我们的应用程序实际上只是发起了 IO 操作的调用而已，具体 IO 的执行是由操作系统的内核来完成的。

但操作系统向外提供API，其由各种类型的系统调用（System Call）组成，以提供安全的访问控制。所以应用程序要想访问内核管理的I/O，必须通过调用内核提供的系统调用(system call）进行间接访问。

所以I/O之于应用程序来说，强调的通过向内核发起系统调用完成对I/O的间接访问。换句话说应用程序发起的一次IO操作实际包含两个阶段：

  1. IO调用阶段：应用程序进程向内核发起系统调用。
  2. IO执行阶段：内核执行IO操作并返回。准备数据阶段：内核等待I/O设备准备好数据；拷贝数据阶段：将数据从内核缓冲区拷贝到用户空间缓冲区。

UNIX 系统下， IO 模型一共有 5 种：

  • 同步阻塞 I/O、
  • 同步非阻塞 I/O、
  • I/O 多路复用、
  • 信号驱动 I/O
  • 异步 I/O。

推荐孙卫琴老师的书籍：
在这里插入图片描述

2、BIO (Blocking I/O)

2.1、BIO模型解析

BIO即同步阻塞IO，实现模型为一个连接就需要一个线程去处理。这种方式简单来说就是当有客户端来请求服务器时，服务器就会开启一个线程去处理这个请求，即使这个请求不干任何事情，这个线程都一直处于阻塞状态。

应用程序中进程在发起IO调用后至内核执行IO操作返回结果之前，若发起系统调用的线程一直处于等待状态，则此次IO操作为阻塞IO。阻塞IO简称BIO，Blocking IO。其处理流程如下图所示：
在这里插入图片描述
从上图可知当用户进程发起IO系统调用后，内核从准备数据到拷贝数据到用户空间的两个阶段期间用户调用线程选择阻塞等待数据返回。

因此BIO带来了一个问题：如果内核数据需要耗时很久才能准备好，那么用户进程将被阻塞，浪费性能。为了提升应用的性能，虽然可以通过多线程来提升性能，但线程的创建依然会借助系统调用，同时多线程会导致频繁的线程上下文的切换，同样会影响性能。所以要想解决BIO带来的问题，我们就得看到问题的本质，那就是阻塞二字。

BIO模型有很多缺点，最大的缺点就是资源的浪费。想象一下如果QQ使用BIO模型，当有一个人上线时就需要一个线程，即使这个人不聊天，这个线程也一直被占用，那再多的服务器资源都不管用。

2.2、BIO代码演示

使用 BIO 模型编写一个服务器端，监听 6666 端口，当有客户端连接时，就启动一个线程与之通讯。

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @title BIOServer
 * @description 测试
 * @author: yangyongbing
 * @date: 2023/12/7 11:45
 */
public class BIOServer {

    public static void main(String[] args) throws IOException {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务器启动了");
        while (true){
            System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
            //监听，等待客户端连接
            System.out.println("等待连接....");
            final Socket socket = serverSocket.accept();
            System.out.println("连接到一个客户端");
            //一个客户端连接就创建一个线程，并与之建立通讯
            newCachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    //与客户端建立通讯
                    handler(socket);
                }
            });
        }
    }


    public static void handler(Socket socket) {
        try {
            System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
            byte[] bytes = new byte[1024];
            // 通过socket 获取输入流
            InputStream inputStream = socket.getInputStream();
            // 循环的读取客户端发送的数据
            while (true) {
                System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
                System.out.println("read....");
                int index = inputStream.read(bytes);
                if (index != -1) {
                    // 输出客户端发送的数据
                    System.out.println(new String(bytes, 0, index));
                } else {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("关闭和客户端的连接");
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3、NIO (Non-blocking/New I/O)

3.1、NIO模型解析

Java NIO 全称 Java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO（即 NewIO），是同步非阻塞的。

就是用户进程在发起系统调用时指定为非阻塞，内核接收到请求后，就会立即返回，然后用户进程通过轮询的方式来拉取处理结果。也就是如下图所示：
在这里插入图片描述
应用程序中进程在发起IO调用后至内核执行IO操作返回结果之前，若发起系统调用的线程不会等待而是立即返回，则此次IO操作为非阻塞IO模型。非阻塞IO简称NIO，Non-Blocking IO。

BIO是阻塞的，如果没有多线程，BIO就需要一直占用CPU，而NIO则是非阻塞IO，NIO在获取连接或者请求时，即使没有取得连接和数据，也不会阻塞程序。NIO的服务器实现模式为一个线程可以处理多个请求（连接）。
NIO有几个知识点需要掌握，Channel(通道)，Buffer(缓冲区), Selector（多路复用选择器）：

  • Channel既可以用来进行读操作，又可以用来进行写操作。NIO中常用的Channel有FileChannel、SocketChannel、ServerSocketChannel、DatagramChannel。
  • Buffer缓冲区用来发送和接受数据。
  • Selector 一般称为选择器或者多路复用器 。它是Java NIO核心组件中的一个，用于检查一个或多个NIO Channel（通道）的状态是否处于可读、可写。Java在NIO中使用Selector往往是将Channel注册到Selector中，如下图所示：
    在这里插入图片描述
    然而，非阻塞IO虽然相对于阻塞IO大幅提升了性能，但依旧不是完美的解决方案，其依然存在性能问题，也就是频繁的轮询导致频繁的系统调用，会耗费大量的CPU资源。比如当并发很高时，假设有1000个并发，那么单位时间循环内将会有1000次系统调用去轮询执行结果，而实际上可能只有2个请求结果执行完毕，这就会有998次无效的系统调用，造成严重的性能浪费。有问题就要解决，那NIO问题的本质就是频繁轮询导致的无效系统调用。

2.2、NIO代码演示

NIO服务端的执行过程是这样的：

  • 创建一个ServerSocketChannel和Selector，然后将ServerSocketChannel注册到Selector上
  • Selector通过select方法去轮询监听channel事件，如果有客户端要连接时，监听到连接事件
  • 通过channel方法将socketchannel绑定到ServerSocketChannel上，绑定通过SelectorKey实现
  • socketchannel注册到Selector上，关联读事件
  • Selector通过select方法去轮询监听channel事件，当监听到有读事件时，ServerSocketChannel通过绑定的SelectorKey定位到具体的channel，读取里面的数据。
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;

/**
 * @title NIOServer
 * @description NIO测试
 * @author: yangyongbing
 * @date: 2023/12/7 12:02
 */
public class NIOServer {

    public static void main(String[] args) throws IOException{
        //创建一个socket通道，并且设置为非阻塞的方式
        ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.socket().bind(new InetSocketAddress(9000));
        //创建一个selector选择器，把channel注册到selector选择器上
        Selector selector=Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true){
            System.out.println("等待事件发生");
            selector.select();
            System.out.println("有事件发生了");
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove();
                handler(key);
            }
        }
    }

    private static void handler(SelectionKey key) throws IOException {
        if (key.isAcceptable()){
            System.out.println("连接事件发生");
            ServerSocketChannel serverSocketChannel= (ServerSocketChannel) key.channel();
            //创建客户端一侧的channel，并注册到selector上
            SocketChannel socketChannel = serverSocketChannel.accept();
            socketChannel.configureBlocking(false);
            socketChannel.register(key.selector(),SelectionKey.OP_READ);
        }else if (key.isReadable()){
            System.out.println("数据可读事件发生");
            SocketChannel socketChannel= (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int len = socketChannel.read(buffer);
            if (len!=-1){
                System.out.println("读取到客户端发送的数据："+new String(buffer.array(),0,len));
            }
            //给客户端发送信息
            ByteBuffer wrap = ByteBuffer.wrap("hello world".getBytes());
            socketChannel.write(wrap);
            key.interestOps(SelectionKey.OP_READ|SelectionKey.OP_WRITE);
            socketChannel.close();
        }
    }

}

客户端代码：NIO客户端代码的实现比BIO复杂很多，主要的区别在于，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;

/**
 * @title NIOClient
 * @description NIOClient测试
 * @author: yangyongbing
 * @date: 2023/12/7 12:19
 */
public class NIOClient {
    public static void main(String[] args) throws IOException {
        //配置基本的连接参数
        SocketChannel channel = SocketChannel.open();
        channel.configureBlocking(false);
        Selector selector = Selector.open();
        channel.connect(new InetSocketAddress("127.0.0.1", 9000));
        channel.register(selector, SelectionKey.OP_CONNECT);

        //轮询访问selector
        while (true) {
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();
                //连接事件发生
                if (key.isConnectable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    //如果正在连接，则完成连接
                    if (socketChannel.isConnectionPending()) {
                        socketChannel.finishConnect();
                    }
                    socketChannel.configureBlocking(false);
                    ByteBuffer buffer = ByteBuffer.wrap("客户端发送的数据".getBytes());
                    socketChannel.write(buffer);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    //读取服务端发送过来的消息
                    read(key);
                }
            }
        }
    }

    private static void read(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(512);
        int len = socketChannel.read(buffer);
        if (len != -1) {
            System.out.println("客户端收到信息：" + new String(buffer.array(), 0, len));
        }
    }

}

效果大概是这样的：首先服务端等待事件发生，当客户端启动时，服务器端先接受到连接的请求，接着接受到数据读取的请求，读完数据后继续等待。

NIO通过一个Selector，负责监听各种IO事件的发生，然后交给后端的线程去处理。NIO相比与BIO而言，非阻塞体现在轮询处理上。BIO后端线程需要阻塞等待客户端写数据，如果客户端不写数据就一直处于阻塞状态。而NIO通过Selector进行轮询已注册的客户端，当有事件发生时才会交给后端去处理，后端线程不需要等待。

3、AIO (Non-blocking/New I/O)

3.1、AIO模型解析

异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。
在这里插入图片描述
目前来说 AIO 的应用还不是很广泛。Netty 之前也尝试使用过 AIO，不过又放弃了。这是因为，Netty 使用了 AIO 之后，在 Linux 系统上的性能并没有多少提升。

3.2、AIO代码演示

AIO是在JDK1.7中推出的新的IO方式–异步非阻塞IO，也被称为NIO2.0，AIO在进行读写操作时，直接调用API的read和write方法即可，这两种均是异步的方法，且完成后会主动调用回调函数。简单来讲，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。

Java提供了四个异步通道：AsynchronousSocketChannel、AsynchronousServerSocketChannel、AsynchronousFileChannel、AsynchronousDatagramChannel。

服务器端代码：AIO的创建方式和NIO类似，先创建通道，再绑定，再监听。只不过AIO中使用了异步的通道。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.concurrent.TimeUnit;

/**
 * @title AIOServer
 * @description AIOServer测试
 * @author: yangyongbing
 * @date: 2023/12/7 12:41
 */
public class AIOServer {
    public static void main(String[] args) {
        try {
            //创建异步通道
            AsynchronousServerSocketChannel serverSocketChannel=AsynchronousServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(8080));
            System.out.println("等待连接中");
            //在AIO中，accept有两个参数，
            // 第一个参数是一个泛型，可以用来控制想传递的对象
            // 第二个参数CompletionHandler，用来处理监听成功和失败的逻辑
            //  如此设置监听的原因是因为这里的监听是一个类似于递归的操作，每次监听成功后要开启下一个监听
            serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
                //请求成功处理逻辑
                @Override
                public void completed(AsynchronousSocketChannel result, Object attachment) {
                    System.out.println("连接成功，处理数据中");
                    //开启新的监听
                    serverSocketChannel.accept(null,this);
                    handlerData(result);
                }
                @Override
                public void failed(Throwable exc, Object attachment) {
                    System.out.println("失败");
                }
            });
            try {
                TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handlerData(AsynchronousSocketChannel result) {
        ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
        //通道的read方法也带有三个参数
        //1.目的地：处理客户端传递数据的中转缓存，可以不使用
        //2.处理客户端传递数据的对象
        //3.处理逻辑，也有成功和不成功的两个写法
        result.read(byteBuffer, byteBuffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                if (result>0){
                    attachment.flip();
                    byte[] array = attachment.array();
                    System.out.println(new String(array));
                }
            }
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("失败");
            }
        });
    }
}

客户端代码:主要实现数据的发送功能

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Scanner;

/**
 * @title AIOClient
 * @description AIOClient
 * @author: yangyongbing
 * @date: 2023/12/7 12:44
 */
public class AIOClient {
    public static void main(String[] args) {
        try {
            AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
            Scanner scanner = new Scanner(System.in);
            String next = scanner.next();
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            byteBuffer.put(next.getBytes());
            byteBuffer.flip();
            socketChannel.write(byteBuffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4、总结

I/O 其关键点是要将应用程序的IO操作分为两个步骤来理解：IO调用和IO执行。IO调用才是应用程序干的事情，而IO执行是操作系统的工作。在IO调用时，对待操作系统IO就绪状态的不同方式，决定了其是阻塞或非阻塞模式；在IO执行时，线程或进程是否挂起等待IO执行决定了其是否为同步或异步IO。

码说芯语
关注
  • 0
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
本篇文章主要介绍了Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码），具有一定的参考价值，感兴趣的小伙伴们可以参考一下
一站式学习Java网络编程 全面理解BIO:NIO:AIO1
08-08
全面理解 Java 网络编程 - BIO、NIO、AIO 本课程旨在帮助学生全面理解 Java 网络编程中的 BIO、NIO、AIO 三剑客，掌握 RPC 编程的基础知识，并结合实战项目巩固所学。 一、网络编程三剑客 - BIO、NIO、AIO BIO...
Java核心（五）深入理解BIO、NIO、AIO
moneywenxue的博客
02-04 186
导读：本文你将获取到：同/异步 + 阻/非阻塞的性能区别；BIO、NIO、AIO 的区别；理解和实现 NIO 操作 Socket 时的多路复用；同时掌握 IO 最底层最核心的操作技巧。 BIO、NIO、AIO 的区别是什么？ 同/异步、阻/非阻塞的区别是什么？ 文件读写最优雅的实现方式是什么？ NIO 如何实现多路复用功能？ 带着以上这几个问题，让我们一起进入IO的世界吧。 在开始之前，我们先来思考一个问题：我们经常所说的“IO”的全称到底是什么？ 可能很多人看到这个问题和我一样一脸懵逼，
Java网络编程IO模型 --- BIO、NIO、AIO详解
2301_82242988的博客
04-29 661
金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：大厂面试真题：金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：[外链图片转存中…(img-3ST7KdL7-1714389491204)]大厂面试真题：[外链图片转存中…(img-wIJZpwVt-1714389491205)]本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
Java学习（BIO编程、NIO、AIO及其区别）
weixin_48079072的博客
02-13 209
BIO编程 使用统一接口进行操作，具体实现细节无关 字节流 InputStream和OutputStream，都实现了Closeable接口，所以支持try-resources InputStream操作用于实现数据的读取操作 read():int 注意这里只是读取一个字节，0-255之间，-1表示流结束 read(byte[]):int 返回值表示读取的具体字节个数，-1流结束 close():void 关闭流 另外不重要的方法 read(byte[],int,int) available
java网络编程_Java网络编程详解（BIO、NIO、AIO）
weixin_39736150的博客
11-14 93
本文会从传统的BIO到NIO再到AIO自浅至深介绍，并附上完整的代码讲解。网络编程的基本模型是C/S模型，即两个进程间的通信。服务端提供IP和监听端口，客户端通过连接操作向服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。在了解BIO，NIO，AIO之前先了解一下IO的几个概念:　1、同步：用户进程触发IO操作并等待或者轮询的去查看IO操作是否就绪。 ...
读书笔记：java网络编程BIONIO, AIO 源码示例.zip
最新发布
07-19
读书笔记：java网络编程BIONIO, AIO 源码示例
读书笔记：Java网络编程BIO、NIO、AIO.zip
07-19
读书笔记：Java网络编程BIO、NIO、AIO
Java中BIO、NIO、AIO的理解
08-28
"Java中BIO、NIO、AIO的理解" Java中BIO、NIO、AIO的理解是Java高性能IO体系设计中三个重要的概念。它们都是Java中IO操作的实现方式，但它们之间有着很大的区别。 首先，我们需要了解什么是同步和异步，什么是阻塞...
Java 网络编程之 BIO、NIO、AIO
qq_54429571的博客
11-24 866
Java 网络编程之 BIO、NIO、AIO 深入解析。
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（八）
好想去看海
10-03 286
目录1. AIO模型分析2. 聊天室分析2.1 服务器端2.1.1 字段2.1.2 主方法2.1.3 AcceptHandler2.1.4 ClientHandler（处理读写请求）2.1.5 添加和删除用户2.1.6 接收和转发方法2.2 客户端2.2.1 主方法2.2.2 发送消息2.2.3 用户的输入线程3. 测试结果4.完整代码4.1 服务器端4.2 客户端 1. AIO模型分析 AsynchronousServerSocket：它属于一个 AsynchronousChannelGroup,这
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（六）
好想去看海
09-30 256
文章目录1. NIO模型分析2.聊天室项目代码重点知识2.1 服务器端2.1.1 字段2.1.2 主方法2.1.3 处理方法2.1.4 转发消息方法2.1.5 接收消息方法2.2 客户端2.2.1 字段2.2.2 主方法2.2.3 处理方法2.2.4 接收方法2.2.5 发送方法3. 测试结果4. 完整代码4.1 服务器端4.2 客户端4.3 客户端监听用户输入进程 1. NIO模型分析 在服务器端创建一个Selector，将ServerSocketChannel注册到Selector上，被Selec
BIO，NIO和AIO是Java网络编程的三种模型学习教程
liuyaokai1990的博客
09-21 429
BIO，NIO和AIO是Java网络编程的三种模型 BIO：同步并阻塞，服务实现模式为一个连接对应一个线程，即客户端发送一个连接，服务端要有一个线程来处理。如果连接多了，线程数量不够，就只能等待，即会发生阻塞。 NIO：同步非阻塞，服务实现模式是一个线程可以处理多个连接，即客户端发送的连接都会注册到多路复用器上，然后进行轮询连接，有I/O请求就处理 AIO：异步非阻塞，引入了异步通道，采用的是proactor模式，特点是：有效的请求才启动线程，先有操作系统完成在通知服务端
Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
Flyer的后花园
06-04 796
转载请注明出处：http://blog.csdn.net/anxpp/article/details/51512200，谢谢！     本文会从传统的BIO到NIO再到AIO自浅至深介绍，并附上完整的代码讲解。     下面代码中会使用这样一个例子：客户端发送一段算式的字符串到服务器，服务器计算后返回结果到客户端。     代码的所有说明，都直接作为注释，嵌入到代码中，看代码时就
Java网络编程IO模式：BIO，NIO，AIO
弋尔的博客
10-17 193
IO模型 IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO
一站式学习Java网络编程 全面理解BIO_NIO_AIO，学习手记（五）
好想去看海
09-26 151
目录1.1 翻译翻译？什么叫NIO？1.2 Buffer简介1.2.1 写模式1.2.2 读模式到写模式的两种切换1.3 Channel简介1.3.1 几个重要的Channel2. 文件拷贝实战 1.1 翻译翻译？什么叫NIO？ NIO：我认为翻译成Non-Blocking，更加的通俗直白，相比于BIO，也有一个对比，叫他非阻塞IO最好不过了 它和BIO有以下的区别 Channel是双向的，即可以读又可以写，相比于Stream，它并不区分出输入流和输出流，而且Channel可以完成非阻塞的读写，也可以
java BIO、NIO、AIO详细笔记
殷志鹏的博客
01-21 1113
详细介绍NIO和AIO
Java 网络 IO（BIO、NIO、AIO）
沈小洋
04-07 502
NIO提供的MappedByteBuffer支持支持在内存（堆外内存）中修改文件，可以减少一次数据拷贝。代码示例/*** 说明 1.MappedByteBuffer 可让文件直接在内存（堆外内存）修改,操作系统不需要拷贝一次*///获取对应的通道/*** 参数 1:FileChannel.MapMode.READ_WRITE 使用的读写模式* 参数 2：0：可以直接修改的起始位置* 参数 3:5: 是映射到内存的大小（不是索引位置），即将 1.txt 的多少个字节映射到内存。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值