NIO_socketchannel如何判断是否剩余数据-CSDN博客

本文链接：https://blog.csdn.net/XXY411636013/article/details/93061548

NIO

什么是NIO ？

NIO 是 Java 1.4 版本开始引入的一个新的 IO API ，
可以替代标准的 Java IO API 。NIO 与原来的 IO 有同样的作用和目的，但是使用的方式完全不同， NIO 支持面向缓冲区的、基于通道的 IO 操作。 NIO 将以更加高效的方式进行文件的读写操作.

Java IO 与 NIO 的区别

1、面向流与面向缓冲

Java IO和NIO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

2、阻塞与非阻塞IO

Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

3、选择器（Selectors）

Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

IO	NIO
面向流(StreamOriented)	面向缓冲区(BufferOriented)
阻塞IO(BlockingIO)	非阻塞IO(NonBlockingIO)
(无)	选择器(Selectors)

通道与缓冲区：

通道（Channel）负责传输，缓冲区（ Buffer ）负责存储

Buffer缓冲区中几个重要的属性：

capacity：

缓冲区的最大容量

position：

读取数据是，具体位置

limit：

界限

mark：

书签，标记，可以记录 position 可以通过一个方法，会到我刚才标记的位置

容器：

有两个方法，可以写入数据和读取数据

public class MyTest2 {
public static void main(String[] args) {
    String str = "abcde";
    ByteBuffer byteBuffer = ByteBuffer.allocate(10);
    byteBuffer.put(str.getBytes());
    //转换成读取模式
    byteBuffer.flip();
    byte[] bytes = new byte[byteBuffer.limit()];
    byteBuffer.get(bytes, 0, 2);
    System.out.println("position:" + byteBuffer.position());
    byteBuffer.mark(); //记录 positon的位置
    byteBuffer.get(bytes, 2, 2);
    System.out.println("position:" + byteBuffer.position());
    byteBuffer.reset();//回到上次记录的positonde位置
    System.out.println("position:" + byteBuffer.position());

    System.out.println("position:" + byteBuffer.position());
    System.out.println("limit:" + byteBuffer.limit());
    //byteBuffer.get(bytes,2,3);
    //System.out.println(new String(bytes));
    if (byteBuffer.hasRemaining()) {//判断是否还有剩余数据
        System.out.println(byteBuffer.remaining()); //还剩多少数据
    }
}
}

缓冲区常用方法：

put() :

存入数据到缓冲区中

put(byte[] src) ：

将 src 中的字节写入缓冲区的当前位置

put(int index, byte b) ：

将指定字节写入缓冲区的索引位置 ( 不会移动 position

get() :

获取缓冲区中的数据

get(byte[] dst) ：

批量读取多个字节到 dst 中

get(int index) ：

读取指定索引位置的字节 ( 不会移动 position)

flip();

切换读取数据模式

rewind() :

可重复读

clear() :

清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态

mark() :

标记是一个索引，通过 Buffer 中的 mark() 方法
指定 Buffer 中一个特定的 position ，之后可以通过调用 reset() 方法恢复到这
个 position.

直接缓冲区与非直接缓冲区

非直接缓冲区

直接缓冲区

通道（Channel）

让源节点和目标节点建立连接，通道本身不存储数据，他跟缓冲区进行交互

FileChannel：

本地文件传输通道
用于读取、写入、映射和操作文件的通道

DatagramChannel ：

网络数据传输的通道
通过 UDP 读写网络中的数据通道

SocketChannel ：

网络数据传输的通道
通过 TCP 读写网络中的数据。

ServerSocketChannel ：

网络数据传输的通道
可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel

获取通道的几种方式：

方式1：

通过
FileInputStream
FileOutputStream
RandomAccessFile
中的getChannel()方法可以获取通道

public class MyTest {
public static void main(String[] args) throws IOException {
    FileInputStream in = new FileInputStream("领悟.mp3");
    FileOutputStream out = new FileOutputStream("领悟2.mp3");
    //获取通道
    FileChannel inChannel = in.getChannel();
    FileChannel outChannel = out.getChannel();
    //定义缓冲区
    ByteBuffer byteBuffer = ByteBuffer.allocate(1024); //用的是非直接缓冲区
    while (inChannel.read(byteBuffer) != -1) {
        //切换读取模式
        byteBuffer.flip();
        outChannel.write(byteBuffer);
        byteBuffer.clear();//清空缓冲区
    }
    in.close();
    out.close();
    inChannel.close();
    outChannel.close();
}
}

方式2

通过
FileChannel
中的静态方法 open() 可以打开通道

public class MyTest2 {
public static void main(String[] args) throws IOException {
    long start = System.currentTimeMillis();
    FileChannel inChannel = FileChannel.open(Paths.get("D:\\IntelliJIDEA2018.2.6.7z"), StandardOpenOption.READ);
    //StandardOpenOption.CREATE 文件不存在，就创建,如果存在，就覆盖
    // StandardOpenOption.CREATE_NEW 文件不存在就创建，如果存在，就报错
    FileChannel outChannel = FileChannel.open(Paths.get("E:\\IntelliJIDEA20182222.7z"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

    //定义缓冲区
    ByteBuffer byteBuffer = ByteBuffer.allocate(1024); //用的是非直接缓冲区
    while (inChannel.read(byteBuffer) != -1) {
        //切换读取模式
        byteBuffer.flip();
        outChannel.write(byteBuffer);
        byteBuffer.clear();//清空缓冲区
    }

    inChannel.close();
    outChannel.close();
    long end = System.currentTimeMillis();
    System.out.println("耗时"+(end-start)+"毫秒");
    //耗时43228毫秒
}
}

方式3

Files.newByteChannel()

方式4

Channels.newChannel()

使用非直接缓冲区复制文件

public static void main(String[] args) throws IOException {
    //创建文件输入输入流
    FileInputStream in = new FileInputStream("短发.mp3");
    FileOutputStream out = new FileOutputStream("短发2.mp3");
    //文件输入输入流的getChannel()方法获取通道
    FileChannel inChannel = in.getChannel();
    FileChannel outChannel = out.getChannel();
    //获取非直接缓冲区
    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    //将通道中的数据放入到缓冲区中
    while (inChannel.read(byteBuffer) != -1) {
        //切换读取数据的模式
        byteBuffer.flip();
        //将缓冲区中的数据写入通道中
        outChannel.write(byteBuffer);
        //清空缓冲区
        byteBuffer.clear();
    }
    //释放资源
    in.close();
    out.close();
    inChannel.close();
    outChannel.close();
}

使用直接缓冲区复制文件

public static void main(String[] args) throws IOException {
    //通过文件通道的静态方法,打开读写通道
    //参1:通过Paths获取源文件的路径
    //参2:操作模式 StandardOpenOption.READ 读取模式
    //打开读取文件的通道
    FileChannel in = FileChannel.open(Paths.get("短发.mp3"), StandardOpenOption.READ);
    //打开写入的通道 模式要读还要写  StandardOpenOption.CREATE 意思是文件不存在就创建,如果存在就覆盖
    //StandardOpenOption.CREATE_NEW 意思是文件不存在就创建,如果存在就报错
    FileChannel out = FileChannel.open(Paths.get("短发2.mp3"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
    //操作内存映射文件(也就是这个缓冲区在物理内存中)
    MappedByteBuffer inByteBuffer = in.map(FileChannel.MapMode.READ_ONLY, 0, in.size());
    MappedByteBuffer outByteBuffer = out.map(FileChannel.MapMode.READ_WRITE, 0, in.size());
    //直接对缓冲区进行读写操作
    byte[] bytes = new byte[inByteBuffer.limit()];
 	inByteBuffer.get(bytes);
    outByteBuffer.put(bytes);
    //释放资源
    in.close();
    out.close();

}