深入浅出NIO

最新推荐文章于 2024-09-11 09:24:23 发布
最新推荐文章于 2024-09-11 09:24:23 发布
阅读量118 收藏
点赞数
分类专栏： Java 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/come_sky/article/details/112187472
版权

Java NIO由以下核心部分组成

  • Buffer
  • Channel
  • Selector

Buffer

  • ByteBuffer
  • ShortBuffer
  • FloatBuffer
  • CharBuffer
  • IntBuffer
  • LongBuffer
  • DirectByteBuffer
  • HeapByteBuffer
Buffer属性以及相关操作
属性说明
capacity 容量Buffer所能够存放的最大容量
position 位置下一个被读或写的位置
limit 上界可供读写的最大位置,用于限制position position < limit
mark 标记标记位置,用于记录某次读写的位置,可以通过reset()方法回到这里
mark <= position <= limit <= capacity
读写ByteBuffer
// 读操作就是直接读取下一个index的数据
public byte get() {
    return hb[ix(nextGetIndex())];
}
public ByteBuffer get(byte[] dst, int offset, int length) {
    checkBounds(offset, length, dst.length);
    if (length > remaining())
        throw new BufferUnderflowException();
    System.arraycopy(hb, ix(position()), dst, offset, length);
    position(position() + length);
    return this;
}   
// offset就是偏移量,是一个数字的偏移量,这里字节数组所以偏移量为1,如果为intBuffer当然会是4了.
protected int ix(int i) {
    return i + offset;
}
// 然后会检查这里的读是否超过了读的界限.
final int nextGetIndex() {                       
        if (position >= limit)
            throw new BufferUnderflowException();
        return position++;
    }
// 这个方法直接找到下n个位置
final int nextGetIndex(int nb) {                   
    if (limit - position < nb)
        throw new BufferUnderflowException();
    int p = position;
    position += nb;
    return p;
}

// 当然了读操作也不能无限制的读啊,当然的是需要有一个界限了,这里就有了下面这个方法,能够检测是否还能继续读取.可以就返回true
public final boolean hasRemaining() {
        return position < limit;
    }

Channel

Channel分别为本地I/O设备和网络I/O提供了以下实现，并且和Java IO体系的类是一一对应的：

  1. 网络IO
    • DatagramChannel:读写UDP通信的数据，对应DatagramSocket类
    • SocketChannel:读写TCP通信的数据，对应Socket类
    • ServerSocketChannel:监听新的TCP连接，并且会创建一个可读写的SocketChannel，对应ServerSocket类
  2. 本地设备IO
    • FileChannel:读写本地文件的数据,不支持Selector控制，对应File类
ServerSocketChannel

让我们从最简单的 ServerSocketChanne来开始对socket通道类的讨论。以下是ServerSocketChanne的完整 API：

public abstract class ServerSocketChannel extends AbstractSelectableChannel {

    public static ServerSocketChannel open() throws IOException
    public abstract ServerSocket socket();
    public abstract SocketChannel accept() throws IOException;
    //支持的SelectionKey类型，返回OP_ACCEPT
    public final int validOps()
}

新建一个ServerSocketChannelImpl其本质是在底层操作系统创建了一个fd(即文件描述符)，相当于建立了一个用于网络通信的通道，通过这个通道我们可以和外部网络进行通信；

SocketChannel

使用ServerSocketChannel可以实时获取到新建的TCP连接，从上面accpet()方法得出，其返回的是一个SocketChannelImpl对象，其继承的类的是SocketChannel，以下是SocketChannel的API：

public abstract class SocketChannel extends AbstractSelectableChannel implements ByteChannel, ScatteringByteChannel, GatheringByteChannel {
    // 这里仅列出部分API
    public static SocketChannel open() throws IOException
    public static SocketChannel open(InetSocketAddress remote) throws IOException
    public abstract Socket socket();
    public abstract boolean connect (SocketAddress remote) throws IOException;
    // 当前的连接channel是否有并发连接，非阻塞状态下才有可能返回true
    public abstract boolean isConnectionPending();
    //调用finishConnect()方法来完成连接过程，该方法任何时候都可以安全地进行调用。假如在一个非阻塞模式的SocketChannel对象上调用finishConnect()方法，将可能出现下列情形之一：
    /**
    * 1.connect()方法尚未被调用。那么将产生NoConnectionPendingException异常。
    * 2.连接建立过程正在进行，尚未完成。那么什么都不会发生，finishConnect()方法会立即返回false值。
    * 3.在非阻塞模式下调用connect()方法之后，SocketChannel又被切换回了阻塞模式。那么如果有必要的话，调用线程会阻塞直到连接建立完成，finishConnect()方法接着就会返回true值。
    * 4.在初次调用connect()或最后一次调用finishConnect()之后，连接建立过程已经完成。那么SocketChannel对象的内部状态将被更新到已连接状态，finishConnect()方法会返回true值，然后SocketChannel对象就可以被用来传输数据了。
    * 5.连接已经建立。那么什么都不会发生，finishConnect()方法会返回true值。
    */
    public abstract boolean finishConnect() throws IOException;
    // 是否连接成功
    public abstract boolean isConnected();
    
    // 支持的SelectionKey类型，返回OP_CONNECT,OP_READ,OP_WRITE
    public final int validOps();
    
    public abstract int read(ByteBuffer dst) throws IOException;
    public abstract int write(ByteBuffer src) throws IOException;
}

上文我们提到SocketChannel是用于读写TCP通信的数据，与Socket类一致，其封装的是点对点、有序的网络连接；一个SocketChannel的创建必然伴随着会创建一个同等的Socket对象(实际是SocketAdaptor)，通过socket方法能获取；

DatagramChannel

DatagramChannel是NIO中面向Datagram(数据报)的套接字通道.

一般我们在实际编程中用到这个Channel的情况很少，所以我在这里就不详细说明了。

FileChannel

FileChannel是线程安全的，只能通过FileInputStream,FileOutputStream,RandomAccessFile的getChannel方法获取FileChannel通道，原理是获取到底层操作系统生成的fd(file descriptor)

Selector

想想一个场景：在一个养鸡场，有这么一个人，每天的工作就是不停检查几个特殊的鸡笼，如果有鸡进来，有鸡出去，有鸡生蛋，有鸡生病等等，就把相应的情况记录下来，如果鸡场的负责人想知道情况，只需要询问那个人即可。
在这里，这个人就相当Selector，每个鸡笼相当于一个SocketChannel，每个线程通过一个Selector可以管理多个SocketChannel。

为了实现Selector管理多个SocketChannel，必须将具体的SocketChannel对象注册到Selector，并声明需要监听的事件（这样Selector才知道需要记录什么数据），一共有4种事件：

  1. connect：客户端连接服务端事件，对应值为SelectionKey.OP_CONNECT(8)
  2. accept：服务端接收客户端连接事件，对应值为SelectionKey.OP_ACCEPT(16)
  3. read：读事件，对应值为SelectionKey.OP_READ(1)
  4. write：写事件，对应值为SelectionKey.OP_WRITE(4)

这个很好理解，每次请求到达服务器，都是从connect开始，connect成功后，服务端开始准备accept，准备就绪，开始读数据，并处理，最后写回数据返回。

所以，当SocketChannel有对应的事件发生时，Selector都可以观察到，并进行相应的处理 。

服务端操作过程
  1. 创建ServerSocketChannel实例，并绑定指定端口；
  2. 创建Selector实例；
  3. 将serverSocketChannel注册到selector，并指定事件OP_ACCEPT，最底层的socket通过channel和selector建立关联；
  4. 如果没有准备好的socket，select方法会被阻塞一段时间并返回0；
  5. 如果底层有socket已经准备好，selector的select方法会返回socket的个数，而且selectedKeys方法会返回socket对应的事件（connect、accept、read or write）；
  6. 根据事件类型，进行不同的处理逻辑；

在步骤3中，selector只注册了serverSocketChannel的OP_ACCEPT事件

  1. 如果有客户端A连接服务，执行select方法时，可以通过serverSocketChannel获取客户端A的socketChannel，并在selector上注册socketChannel的OP_READ事件
  2. 如果客户端A发送数据，会触发read事件，这样下次轮询调用select方法时，就能通过socketChannel读取数据，同时在selector上注册该socketChannel的OP_WRITE事件，实现服务器往客户端写数据。
服务端代码示例：
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.nio.charset.StandardCharsets;
import java.util.Iterator;

public class NIOServer {

    public static void main(String[] args) throws Exception {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(9990));
        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        while (selector.select() > 0) {
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey next = iterator.next();
                if (next.isAcceptable()) {
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (next.isReadable()) {
                    SocketChannel channel = (SocketChannel) next.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int len = 0;
                    while ((len = channel.read(byteBuffer)) > 0) {
                        byteBuffer.flip();
                        System.out.println(new String(byteBuffer.array(), 0, len));
                        byteBuffer.clear();
                        ByteBuffer out = ByteBuffer.allocate(1024);
                        out.put("Sure".getBytes(StandardCharsets.UTF_8));
                        out.flip();
                        channel.write(out);
                        out.clear();
                    }
                }
            }
            iterator.remove();
        }
    }

}
客户端代码示例：
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class NIOClient {

    public static void main(String[] args) throws Exception {
        SocketChannel channel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9990));
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        ByteBuffer reve = ByteBuffer.allocate(1024);
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String in = scanner.next();
            buffer.put(in.getBytes(StandardCharsets.UTF_8));
            buffer.flip();
            channel.write(buffer);
            buffer.clear();
            channel.read(reve);
            reve.flip();
            System.out.println(new String(reve.array(), 0, 1024));
        }
        channel.close();
    }

}
清涵
关注
专栏目录
NIO之Channel
赶路人儿
02-23 1248
1、基本概念 Java NIO中，channel用于数据的传输，类似于传统BIO中的流（IOStream）的概念。 我们都知道，系统的I/O都分为两个阶段： 等待就绪：从IO设备将数据读取到内核中的过程； 操作：将数据从内核复制到进程缓冲区的过程。 Channel就可以看作是IO设备和内核区域的一个桥梁，凡是与IO设备交互都必须通过channel，而Buffer就可以看作是内核缓冲区。这样...
深入理解NIO系列 - Channel详解
I Have A Dream
03-04 4206
Channel简介 在Java NIO中，主要有三大基本的组件：Buffer、Channel和Selector，前面两篇文章我们具体介绍了Selector和Buffer,老规矩，就让我们继续慢慢地揭开Channel的神秘面纱吧！ 在Java NIO的世界中，Selector是中央控制器，Buffer是承载数据的容器，而Channel可以说是最基础的门面，它是本地I/O设备、网络I/O的通信桥梁，只...
NIO之Channel详解
雨后是冰雹
06-09 1406
Channel是一个对象,作用是用于源节点和目标节点的连接,在java NIO中负责缓冲区数据的传递。Channel本身不存储数据，因此需要配合缓冲区进行传输。   主要的实现类有如下四个: , 案例-文件复制 参考：https://blog.csdn.net/qq_38526573/article/details/89207100...............
Java网络编程之NIO(ServerSocketChannel/SocketChannel)-yellowcong
10-07 780
NIO编程中，需要知道的的重要概念 通道（Channel，封装的Socket）、缓冲区(ByteBuffer等类，用于服务端和客户端数据传递)、选择器（Selector,用于处理Channel）。NIO处理时异步非阻塞的IO，NIO(只有Selector的一个线程，不断轮询处理Channel)效率比BIO高很多（BIO是一个请求一个线程）。NIO中常用的框架有Netty和Mina。
Day386&387.Nio概述&Nio的Channel通道 -NIO
阿昌爱Java
09-10 1248
Java NIO 概述 Java NIO（New IO 或 Non Blocking IO）是从Java 1.4 版本开始引入的一个新的IO API，可以替代标准的 Java IO API。NIO 支持面向缓冲区的、基于通道的 IO 操作。NIO 将以更加高效的方式进行文件的读写操作。 1.1 阻塞 IO 通常在进行同步 I/O 操作时，如果读取数据，代码会阻塞直至有可供读取的数据。同样，写入调用将会阻塞直至数据能够写入。传统的 Server/Client 模式会基于 TPR（Thread per Requ
深入浅出Netty
01-31
Netty是一种基于Java NIO操作的框架，它提供了异步的事件驱动的网络应用程序框架和工具，用于快速开发可维护的高性能协议服务器和客户端。Netty被广泛应用于互联网协议服务器和客户端的开发，包括但不限于HTTP服务器...
Java_NIO深入浅出.doc
06-09
Java NIO，即New Input/Output，是Java 1.4版本引入的一个新特性，旨在提供一种更高效、更灵活的I/O操作方式，弥补了传统I/O（基于流的I/O）的一些不足。传统的Java I/O模型主要依赖于阻塞式的流，这种模型在处理...
深入浅出MappedByteBuffer.pdf
07-05
《深入浅出MappedByteBuffer》这篇文章主要探讨了Java NIO中MappedByteBuffer这一高效处理大文件的机制，以及与其相关的计算机内存管理概念。首先，我们来详细理解一下这些知识点。 内存管理是计算机系统的重要组成...
深入浅出Netty ppt
11-03
《深入浅出Netty》是针对Java网络编程框架Netty的一份详细讲解材料，由淘宝工程师精心制作，特别适合初学者。Netty是一款高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。...
详解java NIO之Channel（通道）
08-18
主要介绍了详解java NIO之Channel（通道）的相关资料，文中讲解非常详细，示例代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
看动画，学JavaNIO教程22：如何创建 Selector？
人人都是程序员官方博客
05-09 453
看动画，学JavaNIO教程22：如何创建 Selector？ 上一节 介绍了 Selector 的基本原理 这一节 我们来看看如何创建 Selector 创建 Selector 的方式有两种 第一种是 通过 SelectorProvider 类的 openSelector 方法来创建 第二种是 通过 Selector 类的 open 方法来创建 该方法是一个静态方法 可以直接通过类名来调用 我们发现 它的内部 依旧是通过 SelectorProvider 这种方式创建的 所以 在日常开发中 推荐大家使用.
NIO详解（九）：Channel详解
Master-TJ的个人博客
05-20 2141
1. Channel概述 Java NIO的通道类似流，但又有些不同。 Channel既可以从通道中读取数据，又可以写数据到通道。但流的读写通常是单向的。 Channel通道可以异步地读写。 Channel通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。 通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。 1.1 Channel ...
NIO-Channel详解
z2698751935的博客
01-25 1375
⽤于读取、写⼊、映射和操作⽂件的通道。⽂件通道是连接到⽂件的可搜索字节通道。它在其⽂件中有⼀个当前位置，可以查询和修改。⽂件本身包含可变⻓度的字节序列，可以读取和写⼊，并且可以查询其当前⼤⼩。当写⼊的字节超过其当前⼤⼩时，⽂件的⼤⼩增加；⽂件被截断时，其⼤⼩会减⼩。⽂件还可能具有⼀些相关联的元数据，如访问权限、内容类型和上次修改时间；此类不定义元数据访问的⽅法。除了熟悉的字节通道读、写和关闭操作外，此类还定义了以下⽂件特定操作：字节可以以不影响通道当前位置的⽅式在⽂件中的绝对位置读取或写⼊。
nio-channel概述
Diligently
11-29 562
Channel 概述 Channel 是一个通道，可以通过它读取和写入数据，它就像水管一样，网络数据通过 Channel 读取和写入。通道与流的不同之处在于通道是双向的，流只是在一个方向上 移动（一个流必须是 InputStream 或者 OutputStream 的子类），而且通道可以用于 读、写或者同时用于读写。因为 Channel 是全双工的，所以它可以比流更好地映射底 层操作系统的 API。 NIO 中通过 channel 封装了对数据源的操作，通过 channel 我们可以操作数据源，
Java网络编程——NIO三大组件Buffer、Channel、Selector
点滴汇聚，智在积累。——Danny
08-03 1171
Java NIO（Java Non-Blocking IO）也就是非阻塞IO，说是非阻塞IO，其实NIO也支持阻塞IO模型（默认就是），相对于BIO来说，NIO最大的特点是支持IO多路复用模式，可以通过一个线程监控多个IO流(Socket)的状态，来同时管理多个客户端，极大提高了服务器的吞吐能力。在NIO中有3个比较重要的组件：Buffer、Channel、Selector。......
【Java进阶】NIO（三）＜Channel＞
行为产生结果
06-10 735
Channel是一种新的IO的访问方式，用于在字节缓冲区与通道另一侧的实体（可以是文件，也可以是Socket）之间进行传输数据Channel可以双向读写数据，也可以实现异步读写程序不能直接访问Channel，Channel只能与Buffer缓冲区进行交互，即把通道中的数据读到Buffer缓冲区中，程序从缓冲区中读取数据；在写操作时，程序把数据写入Buffer缓冲区中，再把缓冲区的数据写入到Channel中Scatter（发散）、Gather（聚焦）是通道提供的一个重要功能（有时也称为矢量IO）
NIO总结（二） NIO之Channel
盐二白
08-15 222
Channel NIO把它支持的I/O对象抽象为Channel，Channel又称“通道”，类似于原I/O中的流（Stream），但有所区别： 1、流是单向的，通道是双向的，可读可写。 2、流读写是阻塞的，通道可以异步读写。 3、流中的数据可以选择性的先读到缓存中，通道的数据总是要先读到一个缓存中，或从缓存中写入 eg:使用FileChannel(一个用来写、读、映射和操作文件的通道)进行文件...
Netty详解（四）：Channel介绍
最新发布
在都市的雨幕下找寻自我
09-11 855
在Java NIO中，涉及到网络连接的通道有两个：一个是SocketChannel，负责连接的数据传输；提供了对网络连接的抽象，通过它你可以执行基本的读写操作，比如读取数据、写入数据、绑定端口等。它还负责触发各种I/O事件，比如连接建立、关闭、读取就绪等。文件通道，顾名思义，专门操作磁盘文件的通道。需要注意的地方，FileChannel为阻塞模式，不能设置为非阻塞模式。这个接口的设计是为了支持多路复用I/O操作，即在一个单独的线程中监控多个通道的I/O活动。读取DatagramChannel。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值