NIO学习笔记

java的NIO的学习教程，网上一大把，本文只是学习的笔记。

本文参考和复制如下内容：
https://www.cnblogs.com/mikechenshare/p/16587635.html

https://blog.csdn.net/K_520_W/article/details/123454627

https://www.zhihu.com/question/29005375

一、NIO简介

NIO 同步非阻塞IO,多路复用，其目的是提高速度。主要的使用场景是在网络IO。对于传统的文件IO，优势不明显。

NIO是面向缓冲区(Buffer)的。

用实际的实例来学习一下把！

1、NIO复制文件和传统IO复制文件的demo

package com.muxue.utils;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * @author:lipu
 * @Date:2023/2/6 0006
 * @Descrption:com.muxue.utils
 * @Version:1.0
 */
public class SimpleFileTransferTest {

    private long transferFile(File source, File des) throws IOException {
        long startTime = System.currentTimeMillis();

        if (!des.exists())
            des.createNewFile();

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(des));

        //将数据源读到的内容写入目的地--使用数组
        byte[] bytes = new byte[1024 * 1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }

        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    /**
     * 使用nio 拷贝文件
     * @param source
     * @param des
     * @return
     * @throws IOException
     */
    private long transferFileWithNIO(File source, File des) throws IOException {
        long startTime = System.currentTimeMillis();

        if (!des.exists())
            des.createNewFile();

        RandomAccessFile read = new RandomAccessFile(source, "rw");
        RandomAccessFile write = new RandomAccessFile(des, "rw");

        FileChannel readChannel = read.getChannel();
        FileChannel writeChannel = write.getChannel();


        ByteBuffer byteBuffer = ByteBuffer.allocate(1024 * 1024);//1M缓冲区

        while (readChannel.read(byteBuffer) > 0) {
            byteBuffer.flip();
            writeChannel.write(byteBuffer);
            byteBuffer.clear();
        }

        writeChannel.close();
        readChannel.close();
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    public static void main(String[] args) throws IOException {
        SimpleFileTransferTest simpleFileTransferTest = new SimpleFileTransferTest();
        File sourse = new File("F:\\电影\\猜火车-cd1.rmvb");
        File des = new File("F:\\Users\\Desktop\\io.avi");
        File nio = new File("F:\\Users\\Desktop\\nio.avi");

        long time = simpleFileTransferTest.transferFile(sourse, des);
        System.out.println(time + "：普通字节流时间");

        long timeNio = simpleFileTransferTest.transferFileWithNIO(sourse, nio);
        System.out.println(timeNio + "：NIO时间");


    }
}

View Code

这个例子是用来学习的，其实NIO的主要用途不是文件IO，是网络IO，下面讲的都是基于网络IO 。

可简单认为：

IO是面向流的处理，NIO是面向块(缓冲区)的处理

面向流的I/O 系统一次一个字节地处理数据。
一个面向块(缓冲区)的I/O系统以块的形式处理数据。

NIO主要有三个核心部分组成：

buffer缓冲区
Channel管道，它就是读写数据的双向通道
Selector选择器

二、 buffer缓冲区和Channel管道

在NIO中并不是以流的方式来处理数据的，而是以buffer缓冲区和Channel管道配合使用来处理数据。

简单理解一下：Channel管道比作成铁路，buffer缓冲区比作成火车(运载着货物)。

而我们的NIO就是通过Channel管道运输着存储数据的Buffer缓冲区的来实现数据的处理！

要时刻记住：Channel不与数据打交道，它只负责运输数据。与数据打交道的是Buffer缓冲区。

Channel-->运输

Buffer-->数据

相对于传统IO而言，流是单向的。对于NIO而言，有了Channel管道这个概念，我们的读写都是双向的(铁路上的火车能从广州去北京、自然就能从北京返还到广州)！

1、buffer缓冲区核心要点

我们来看看Buffer缓冲区有什么值得我们注意的地方。

Buffer是缓冲区的抽象类：

其中ByteBuffer是用得最多的实现类(在管道中读写字节数据)。

拿到一个缓冲区我们往往会做什么？很简单，就是读取缓冲区的数据/写数据到缓冲区中。所以，缓冲区的核心方法就是:

put()
get()

Buffer类维护了4个核心变量属性来提供关于其所包含的数组的信息。它们是：

容量Capacity

缓冲区能够容纳的数据元素的最大数量。容量在缓冲区创建时被设定，并且永远不能被改变。(不能被改变的原因也很简单，底层是数组嘛)

上界Limit

缓冲区里的数据的总数，代表了当前缓冲区中一共有多少数据。

位置Position

下一个要被读或写的元素的位置。Position会自动由相应的 get( )和 put( )函数更新。

标记Mark

一个备忘位置。用于记录上一次读写的位置。

buffer代码演示：

package com.muxue.utils;

import java.nio.ByteBuffer;

public class BufferTest {

    public static void main(String[] args) {

        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);//1kb
        System.out.println("初始化：limit--》" + byteBuffer.limit());
        System.out.println("初始化：capacity--》" + byteBuffer.capacity());
        System.out.println("初始化：position--》" + byteBuffer.position());
        System.out.println("初始化：mark--》" + byteBuffer.mark());
        System.out.println("----------------------------------------------");

        String str = "Java3y";
        byteBuffer.put(str.getBytes());

        System.out.println("put后：limit--》" + byteBuffer.limit());
        System.out.println("put后：capacity--》" + byteBuffer.capacity());
        System.out.println("put后：position--》" + byteBuffer.position());
        System.out.println("put后：mark--》" + byteBuffer.mark());

        System.out.println("---------filp -------------------------------------");
        byteBuffer.flip();
        System.out.println("filp后：limit--》" + byteBuffer.limit());
        System.out.println("filp后：capacity--》" + byteBuffer.capacity());
        System.out.println("filp后：position--》" + byteBuffer.position());
        System.out.println("filp后：mark--》" + byteBuffer.mark());


    }
}

View Code

运行结果：

现在我想要从缓存区拿数据，怎么拿呀？？

NIO给了我们一个flip()方法。这个方法可以改动position和limit的位置！

还是上面的代码，我们flip()一下后，再看看4个核心属性的值会发生什么变化：

很明显的是：

limit变成了position的位置了
而position变成了0

看到这里的同学可能就会想到了：当调用完filp()时：limit是限制读到哪里，而position是从哪里读

一般我们称filp()为“切换成读模式”

每当要从缓存区的时候读取数据时，就调用filp()“切换成读模式”

读完我们还想写数据到缓冲区，那就使用clear()函数，这个函数会“清空”缓冲区：

数据没有真正被清空，只是被遗忘掉了

2、Channel的技术要点

Channel（通道）：Channel 是一个通道，管道，网络数据通过Channel读取和写入，Channel和流Stream的不同之处在于Channel是双向的，流只在一个方向上移动（InputStream/OutputStream），而Channel可以用于读写同时进行，即Channel是全双工的。

channel的类结构图

我们主要要记住网络读写，也就是 ServerSocketChannel和SocketChannel 。

（1）、网络读写的流程图：

（2）、SocketChannel和ServerSocketChannel对应的事件

这个事件需要注册到Selector，所以需要熟知 channel对应哪几个事件。

三、选择器Selector

selector选择器是NIO中最核心的东西。

selector 的作用就是配合一个线程来管理多个 channel，获取这些 channel 上发生的事件，这些 channel 工作在非阻塞模式下，不会让线程吊死在一个 channel 上。适合连接数特别多，但流量低的场景（low traffic）。

Selector（选择器/多路复用器）：Selector会不断轮询注册在其上的Channel，如果某个Channel上面发生读或者写事件，即该Channel处于就绪状态，它就会被Selector轮询出来，然后通过selectedKeys可以获取就绪Channel的集合，进行后续的I/O操作。

一个线程能够管理多个Channel的状态。

1、为了更好地理解，我们先来写一下NIO在网络中是阻塞的状态代码，随后看看非阻塞是怎么写的就更容易理解了。

是阻塞的就没有Selector选择器了，就直接使用Channel和Buffer就完事了。

服务端代码：

package com.muxue.utils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

/**
 * @author:lipu
 * @Date:2023/2/7 0007
 * @Descrption:com.muxue.utils
 * @Version:1.0
 */
public class BlockServer {

    public static void main(String[] args) throws IOException {

        // 1.获取通道
        ServerSocketChannel server = ServerSocketChannel.open();

        // 2. 绑定链接
        server.bind(new InetSocketAddress(6666));

        // 3. 获取客户端的连接(阻塞的)
        SocketChannel client = server.accept();

            // 4. 要使用NIO，有了Channel，就必然要有Buffer，Buffer是与数据打交道的呢
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 得到文件通道，将客户端传递过来的图片写到本地项目下(写模式、没有则创建)
        FileChannel outChannel = FileChannel.open(Paths.get("new21d.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

        // 6.将客户端传递过来的图片保存在本地中
        while (client.read(buffer) != -1) {

            // 在读之前都要切换成读模式
            buffer.flip();

            outChannel.write(buffer);

            // 读完切换成写模式，能让管道继续读取文件的数据
            buffer.clear();

        }

        // 7.关闭通道
        outChannel.close();
        client.close();
        server.close();
    }

}

View Code

客户端代码：

package com.muxue.utils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

/**
 * @author:lipu
 * @Date:2023/2/7 0007
 * @Descrption:com.muxue.utils
 * @Version:1.0
 */
public class BlockNIOClient {

    public static void main(String[] args) throws IOException {

        // 1. 获取通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 6666));

        // 2. 发送一张图片给服务端吧
        FileChannel fileChannel = FileChannel.open(Paths.get("D:\\Test\\2.jpg"), StandardOpenOption.READ);

        // 3.要使用NIO，有了Channel，就必然要有Buffer，Buffer是与数据打交道的呢
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 4.读取本地文件(图片)，发送到服务器
        while (fileChannel.read(buffer) != -1) {

            // 在读之前都要切换成读模式
            buffer.flip();

            socketChannel.write(buffer);

            // 读完切换成写模式，能让管道继续读取文件的数据
            buffer.clear();
        }

        // 5. 关闭流
        fileChannel.close();
        socketChannel.close();
    }
}

View Code

先运行服务端代码，再运行客户端代码，

idea的根目录下就会有new21d.jpg文件了。

2、NIO非阻塞形态

如果使用非阻塞模式的话，那么我们就可以不显式告诉服务器已经发完数据了。我们下面来看看怎么写：

客户端：

package com.muxue.utils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.OpenOption;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class NoBlockClient {

    public static void main(String[] args) throws IOException {

        //1 开启一个socket通道
        SocketChannel socketChannel=SocketChannel.open(new InetSocketAddress("127.0.0.1",6655));
        //2 设置非阻塞
        socketChannel.configureBlocking(false);

        //3 分配一个Buffer  大小是1m
        ByteBuffer byteBuffer=ByteBuffer.allocate(1024);

        //4  将文件传给服务端
        FileChannel fileChannel=FileChannel.open(Paths.get("E:\\JavaTest\\old.png"), StandardOpenOption.READ);


        //5 文件写入到Buffer里；
        while (fileChannel.read(byteBuffer)!=-1){

            //6 buffer切换读模式
            byteBuffer.flip();

            //7 向服务端发送buffer
            socketChannel.write(byteBuffer);

            //8 buffer 清理，变成写模式
            byteBuffer.clear();
        }

        //9 关闭文件和socker的 Channel
        fileChannel.close();
        socketChannel.close();



    }
}

View Code

服务端：

package com.muxue.utils;

import java.io.File;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Iterator;
import java.util.Set;

public class NoBlockServ {


    public static void main(String[] args) throws IOException {

        //1 卡开启服务端
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //2 设置 非阻塞
        serverSocketChannel.configureBlocking(false);

        //3 绑定端口号
        serverSocketChannel.bind(new InetSocketAddress(6655));

        //4 开启选择器
        Selector selector = Selector.open();

        //5 将服务端socket注册到选择器上，指定接收“监听通道" 事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        //6 轮询选择器上已“就绪”的事件，---》只要select()>0，说明已就绪
        while (selector.select() > 0) {

            //7 获取当前选择器所有注册的“选择键”(已就绪的监听事件)
            Set<SelectionKey> selectionKeySet = selector.selectedKeys();

            // 枚举器 遍历
            Iterator<SelectionKey> iterator = selectionKeySet.iterator();

            // 8  获取已“就绪”的事件，(不同的事件做不同的事)
            while (iterator.hasNext()) {

                SelectionKey selectionKey = iterator.next();
                if (selectionKey.isAcceptable()) {  //接收的事件就绪

                    // 9 服务端的socket 接收到客户端的socket，创建客户端的socket
                    SocketChannel client = serverSocketChannel.accept(); 

                    // 10  客户端socket设置非阻塞
                    client.configureBlocking(false);

                    //11 客户端socket 注册 读事件 -->拿到客户端的连接为了读取通道的数据(监听读就绪事件)
                    client.register(selector, SelectionKey.OP_READ);

                } else if (selectionKey.isReadable()) { // 读事件就绪

                    // 12 获取当前选择器读就绪状态的通道
                    SocketChannel client = (SocketChannel) selectionKey.channel();

                    // 读取数据
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024 * 1024);

                    //得到文件通道，将客户端传递过来的图片写到本地项目下(写模式、没有则创建)
                    FileChannel fileChannel=FileChannel.open(Paths.get("new2.png"), StandardOpenOption.WRITE,StandardOpenOption.CREATE);

                    while (client.read(byteBuffer)!=-1){
                        // 在读之前都要切换成读模式
                        byteBuffer.flip();
                        fileChannel.write(byteBuffer);
                        // 读完切换成写模式，能让管道继续读取文件的数据
                        byteBuffer.clear();
                    }

                }
                // 100 取消选择键(已经处理过的事件，就应该取消掉了)
                iterator.remove();

            }


        }

        serverSocketChannel.close();


    }
}

View Code

收到图片后，给客户端答复的代码：

客户端：

package com.muxue.utils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.OpenOption;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Iterator;

public class NoBlockClient {

    public static void main(String[] args) throws IOException {

        //1 开启一个socket通道
        SocketChannel socketChannel=SocketChannel.open(new InetSocketAddress("127.0.0.1",6655));
        //2 设置非阻塞
        socketChannel.configureBlocking(false);

        //下面是监听接收消息的事件
        Selector selector=Selector.open();
        socketChannel.register(selector, SelectionKey.OP_READ);


        //3 分配一个Buffer  大小是1m
        ByteBuffer byteBuffer=ByteBuffer.allocate(1024);

        //4  将文件传给服务端
        FileChannel fileChannel=FileChannel.open(Paths.get("E:\\JavaTest\\old.png"), StandardOpenOption.READ);


        //5 文件写入到Buffer里；
        while (fileChannel.read(byteBuffer)!=-1){

            //6 buffer切换读模式
            byteBuffer.flip();

            //7 向服务端发送buffer
            socketChannel.write(byteBuffer);

            //8 buffer 清理，变成写模式
            byteBuffer.clear();
        }



        while (selector.select()>0){

            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

            while (iterator.hasNext()){

                SelectionKey selectionKey = iterator.next();

                if(selectionKey.isReadable()){
                    System.out.println("----接收服务端的答复------");

                    SocketChannel readSocket =(SocketChannel) selectionKey.channel();
                    ByteBuffer readBuffer=ByteBuffer.allocate(1024);
                    int readBytes = readSocket.read(readBuffer);
                    readBuffer.flip();

                    System.out.println(new String(readBuffer.array(),0,readBytes));

                    readBuffer.clear();

                }


                iterator.remove();
            }


        }




        //9 关闭文件和socker的 Channel
        fileChannel.close();
        socketChannel.close();



    }
}

View Code

服务端：

package com.muxue.utils;

import java.io.File;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Iterator;
import java.util.Set;

public class NoBlockServ {


    public static void main(String[] args) throws IOException {

        //1 卡开启服务端
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //2 设置 非阻塞
        serverSocketChannel.configureBlocking(false);

        //3 绑定端口号
        serverSocketChannel.bind(new InetSocketAddress(6655));

        //4 开启选择器
        Selector selector = Selector.open();

        //5 将服务端socket注册到选择器上，指定接收“监听通道" 事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        //6 轮询选择器上已“就绪”的事件，---》只要select()>0，说明已就绪
        while (selector.select() > 0) {

            //7 获取当前选择器所有注册的“选择键”(已就绪的监听事件)
            Set<SelectionKey> selectionKeySet = selector.selectedKeys();

            // 枚举器 遍历
            Iterator<SelectionKey> iterator = selectionKeySet.iterator();

            // 8  获取已“就绪”的事件，(不同的事件做不同的事)
            while (iterator.hasNext()) {

                SelectionKey selectionKey = iterator.next();
                if (selectionKey.isAcceptable()) {  //接收的事件就绪

                    // 9 服务端的socket 接收到客户端的socket，创建客户端的socket
                    SocketChannel client = serverSocketChannel.accept();

                    // 10  客户端socket设置非阻塞
                    client.configureBlocking(false);

                    //11 客户端socket 注册 读事件 -->拿到客户端的连接为了读取通道的数据(监听读就绪事件)
                    client.register(selector, SelectionKey.OP_READ);

                } else if (selectionKey.isReadable()) { // 读事件就绪
                    System.out.println("----------------读事件就绪---------------------------");
                    // 12 获取当前选择器读就绪状态的通道
                    SocketChannel client = (SocketChannel) selectionKey.channel();

                    // 读取数据
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                    //得到文件通道，将客户端传递过来的图片写到本地项目下(写模式、没有则创建)
                    FileChannel fileChannel = FileChannel.open(Paths.get("new6.png"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

                    //这里必须是大于0，而非  ！=-1
                    while (client.read(byteBuffer) > 0) {
                        // 在读之前都要切换成读模式
                        byteBuffer.flip();
                        fileChannel.write(byteBuffer);
                        // 读完切换成写模式，能让管道继续读取文件的数据
                        byteBuffer.clear();
                    }
                    //  client.register(selector,SelectionKey.OP_WRITE);
                    System.out.println("----------------告知客户端---------------------------");

                    ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
                    writeBuffer.put("图片已收到，谢谢。".getBytes());
                    writeBuffer.flip();
                    client.write(writeBuffer);
                    //byteBuffer.clear();


                }
                // 100 取消选择键(已经处理过的事件，就应该取消掉了)
                iterator.remove();

            }


        }

        serverSocketChannel.close();


    }
}

View Code

posted @ 2023-02-06 16:59 沐雪架构师阅读(30) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

沐雪架构师

技术架构

NIO学习笔记

一、NIO简介

二、 buffer缓冲区和Channel管道

1、buffer缓冲区核心要点

2、Channel的技术要点

三、选择器Selector

公告