JDK10都发布了，nio你了解多少？

前言

只有光头才能变强

回顾前面：

本来我预想是先来回顾一下传统的IO模式的，将传统的IO模式的相关类理清楚(因为IO的类很多)。

但是，发现在整理的过程已经有很多优秀的文章了，而我自己来整理的话可能达不到他们的水平。并且传统的IO估计大家都会用，而NIO就不一定了。

下面我就贴几张我认为整理比较优秀的思维导图(下面会给出图片来源地址，大家可前往阅读)：

按操作方式分类结构图：

image

字节流的输入和输出对照图：

GVkFLAA.jpg

字符流的输入和输出对照图：

GxGq3GL.jpg

按操作对象分类结构图：

image

上述图片原文地址，知乎作者@小明：

还有阅读传统IO源码的优秀文章：

相信大家看完上面两个给出的链接+理解了包装模式就是这么简单啦，传统的IO应该就没什么事啦~~

而NIO对于我来说可以说是挺陌生的，在当初学的时候是接触过的。但是一直没有用它，所以停留认知：nio是jdk1.4开始有的，比传统IO高级。

相信很多初学者都跟我一样，对NIO是不太了解的。而我们现在jdk10都已经发布了，jdk1.4的nio都不知道，这有点说不过去了。

所以我花了几天去了解NIO的核心知识点，期间看了《Java 编程思想》和《疯狂Java 讲义》的nio模块。但是，会发现看完了之后还是很迷，不知道NIO这是干嘛用的，而网上的资料与书上的知识点没有很好地对应。

  • 网上的资料很多都以IO的五种模型为基础来讲解NIO，而IO这五种模型其中又涉及到了很多概念：同步/异步/阻塞/非阻塞/多路复用，而不同的人又有不同的理解方式。
  • 还有涉及到了unix的select/epoll/poll/pselect，fd这些关键字，没有相关基础的人看起来简直是天书
  • 这就导致了在初学时认为nio远不可及

我在找资料的过程中也收藏了好多讲解NIO的资料，这篇文章就是以初学的角度来理解NIO。也算是我这两天看NIO的一个总结吧。

  • 希望大家可以看了之后知道什么是NIO，NIO的核心知识点是什么，会使用NIO~

那么接下来就开始吧，如果文章有错误的地方请大家多多包涵，不吝在评论区指正哦~

声明：本文使用JDK1.8

一、NIO的概述

JDK 1.4中的java.nio.*包中引入新的Java I/O库，其目的是提高速度。实际上，“旧”的I/O包已经使用NIO重新实现过，即使我们不显式的使用NIO编程，也能从中受益。

  • nio翻译成 no-blocking io 或者 new io 都无所谓啦，都说得通~

在《Java编程思想》读到“即使我们不显式的使用NIO编程，也能从中受益”的时候，我是挺在意的，所以：我们测试一下使用NIO复制文件和传统IO复制文件的性能：


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

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;
    }

    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:\\电影\\[电影天堂www.dygod.cn]猜火车-cd1.rmvb");
        File des = new File("X:\\Users\\ozc\\Desktop\\io.avi");
        File nio = new File("X:\\Users\\ozc\\Desktop\\nio.avi");

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

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

    }

}

我分别测试了文件大小为13M，40M，200M的：

D3rUfWn.png
oKeyMcp.png
tFLM6cu.png

1.1为什么要使用NIO

可以看到使用过NIO重新实现过的传统IO根本不虚，在大文件下效果还比NIO要好(当然了，个人几次的测试，或许不是很准)

  • 而NIO要有一定的学习成本，也没有传统IO那么好理解。

那这意味着我们可以不使用/学习NIO了吗？

答案是否定的，IO操作往往在两个场景下会用到：

  • 文件IO
  • 网络IO

NIO的魅力：在网络中使用IO就可以体现出来了！

  • 后面会说到网络中使用NIO，不急哈~

二、NIO快速入门

首先我们来看看IO和NIO的区别：

image
  • 可简单认为：IO是面向流的处理，NIO是面向块(缓冲区)的处理
    • 面向流的I/O 系统一次一个字节地处理数据。
    • 一个面向块(缓冲区)的I/O系统以块的形式处理数据。

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

  • buffer缓冲区
  • Channel管道
  • Selector选择器

2.1buffer缓冲区和Channel管道

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

简单理解一下：

  • Channel管道比作成铁路，buffer缓冲区比作成火车(运载着货物)

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

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

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

2.1.1buffer缓冲区核心要点

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

Buffer是缓冲区的抽象类：

fcrYLrh.png

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

Pmu4TRr.png

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

  • put()
  • get()
cRZirXk.png
0TJJCEp.png

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

  • 容量Capacity
    • 缓冲区能够容纳的数据元素的最大数量。容量在缓冲区创建时被设定，并且永远不能被改变。(不能被改变的原因也很简单，底层是数组嘛)
  • 上界Limit
    • 缓冲区里的数据的总数，代表了当前缓冲区中一共有多少数据。
  • 位置Position
    • 下一个要被读或写的元素的位置。Position会自动由相应的 get( )和 put( )函数更新。
  • 标记Mark
    • 一个备忘位置。用于记录上一次读写的位置。
image

2.1.2buffer代码演示

首先展示一下是如何创建缓冲区的，核心变量的值是怎么变化的。


    public static void main(String[] args) {

        // 创建一个缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        // 看一下初始时4个核心变量的值
        System.out.println("初始时-->limit--->"+byteBuffer.limit());
        System.out.println("初始时-->position--->"+byteBuffer.position());
        System.out.println("初始时-->capacity--->"+byteBuffer.capacity());
        System.out.println("初始时-->mark--->" + byteBuffer.mark());

        System.out.println("--------------------------------------");

        // 添加一些数据到缓冲区中
        String s = "Java3y";
        byteBuffer.put(s.getBytes());

        // 看一下初始时4个核心变量的值
        System.out.println("put完之后-->limit--->"+byteBuffer.limit());
        System.out.println("put完之后-->position--->"+byteBuffer.position());
        System.out.println("put完之后-->capacity--->"+byteBuffer.capacity());
        System.out.println("put完之后-->mark--->" + byteBuffer.mark());
    }

运行结果：

1ZRbWTf.png

现在我想要从缓存区拿数据，怎么拿呀？？NIO给了我们一个flip()方法。这个方法可以改动position和limit的位置！

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

image

很明显的是：

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

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

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

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

切换成读模式之后，我们就可以读取缓冲区的数据了：


        // 创建一个limit()大小的字节数组(因为就只有limit这么多个数据可读)
        byte[] bytes = new byte[byteBuffer.limit()];

        // 将读取的数据装进我们的字节数组中
        byteBuffer.get(bytes);

        // 输出数据
        System.out.println(new String(bytes, 0, bytes.length));
image

随后输出一下核心变量的值看看：

image

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

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

2.1.3FileChannel通道核心要点

8qQ8iH0.png

Channel通道只负责传输数据、不直接操作数据的。操作数据都是通过Buffer缓冲区来进行操作！


        // 1\. 通过本地IO的方式来获取通道
        FileInputStream fileInputStream = new FileInputStream("F:\\3yBlog\\JavaEE常用框架\\Elasticsearch就是这么简单.md");

        // 得到文件的输入通道
        FileChannel inchannel = fileInputStream.getChannel();

        // 2\. jdk1.7后通过静态方法.open()获取通道
        FileChannel.open(Paths.get("F:\\3yBlog\\JavaEE常用框架\\Elasticsearch就是这么简单2.md"), StandardOpenOption.WRITE);

使用FileChannel配合缓冲区实现文件复制的功能：

kQujJ3b.png

使用内存映射文件的方式实现文件复制的功能(直接操作缓冲区)：

aDR7cWl.png

通道之间通过transfer()实现数据的传输(直接操作缓冲区)：

3L5y8mZ.png

2.1.4直接与非直接缓冲区

  • 非直接缓冲区是需要经过一个：copy的阶段的(从内核空间copy到用户空间)
  • 直接缓冲区不需要经过copy阶段，也可以理解成--->内存映射文件，(上面的图片也有过例子)。
image
4jtMYGh.png

使用直接缓冲区有两种方式：

  • 缓冲区创建的时候分配的是直接缓冲区
  • 在FileChannel上调用map()方法，将文件直接映射到内存中创建
image

2.1.5scatter和gather、字符集

这个知识点我感觉用得挺少的，不过很多教程都有说这个知识点，我也拿过来说说吧：

  • 分散读取(scatter)：将一个通道中的数据分散读取到多个缓冲区中
  • 聚集写入(gather)：将多个缓冲区中的数据集中写入到一个通道中
image
image

分散读取

knSBEN3.png

聚集写入

image

字符集(只要编码格式和解码格式一致，就没问题了)

pk6Mdmz.png

三、IO模型理解

文件的IO就告一段落了，我们来学习网络中的IO~~为了更好地理解NIO，**我们先来学习一下IO的模型**

根据UNIX网络编程对I/O模型的分类，在UNIX可以归纳成5种I/O模型：

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

3.0学习I/O模型需要的基础

3.0.1文件描述符

Linux 的内核将所有外部设备都看做一个文件来操作，对一个文件的读写操作会调用内核提供的系统命令(api)，返回一个file descriptor（fd，文件描述符）。而对一个socket的读写也会有响应的描述符，称为socket fd（socket文件描述符），描述符就是一个数字，指向内核中的一个结构体（文件路径，数据区等一些属性）。

  • 所以说：在Linux下对文件的操作是利用文件描述符(file descriptor)来实现的。

3.0.2用户空间和内核空间

为了保证用户进程不能直接操作内核（kernel），保证内核的安全，操心系统将虚拟空间划分为两部分

  • 一部分为内核空间。
  • 一部分为用户空间。

3.0.3I/O运行过程

我们来看看IO在系统中的运行是怎么样的(我们以read为例)

image

可以发现的是：当应用程序调用read方法时，是需要等待的--->从内核空间中找数据，再将内核空间的数据拷贝到用户空间的。

  • 这个等待是必要的过程！

下面只讲解用得最多的3个I/0模型：

  • 阻塞I/O
  • 非阻塞I/O
  • I/O多路复用

3.1阻塞I/O模型

在进程(用户)空间中调用recvfrom，其系统调用直到数据包到达且被复制到应用进程的缓冲区中或者发生错误时才返回，在此期间一直等待。

vdKFA3D.png

3.2非阻塞I/O模型

recvfrom从应用层到内核的时候，如果没有数据就直接返回一个EWOULDBLOCK错误，一般都对非阻塞I/O模型进行轮询检查这个状态，看内核是不是有数据到来。

image

3.3I/O复用模型

前面也已经说了：在Linux下对文件的操作是利用文件描述符(file descriptor)来实现的。

在Linux下它是这样子实现I/O复用模型的：

  • 调用select/poll/epoll/pselect其中一个函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。

比如poll()函数是这样子的：int poll(struct pollfd *fds,nfds_t nfds, int timeout);

其中 pollfd 结构定义如下：


struct pollfd {
    int fd;         /* 文件描述符 */
    short events;         /* 等待的事件 */
    short revents;       /* 实际发生了的事件 */
};
image
image
  • （1）当用户进程调用了select，那么整个进程会被block；
  • （2）而同时，kernel会“监视”所有select负责的socket；
  • （3）当任何一个socket中的数据准备好了，select就会返回；
  • （4）这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程(空间)。
  • 所以，I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符其中的任意一个进入读就绪状态，select()函数就可以返回。

select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。

3.4I/O模型总结

正经的描述都在上面给出了，不知道大家理解了没有。下面我举几个例子总结一下这三种模型：

阻塞I/O：

  • Java3y跟女朋友去买喜茶，排了很久的队终于可以点饮料了。我要绿研，谢谢。可是喜茶不是点了单就能立即拿，于是我在喜茶门口等了一小时才拿到绿研。
    • 在门口干等一小时

非阻塞I/O：

  • Java3y跟女朋友去买一点点，排了很久的队终于可以点饮料了。我要波霸奶茶，谢谢。可是一点点不是点了单就能立即拿，同时服务员告诉我：你大概要等半小时哦。你们先去逛逛吧~于是Java3y跟女朋友去玩了几把斗地主，感觉时间差不多了。于是又去一点点问：请问到我了吗？我的单号是xxx。服务员告诉Java3y：还没到呢，现在的单号是XXX，你还要等一会，可以去附近耍耍。问了好几次后，终于拿到我的波霸奶茶了。
    • 去逛了下街、斗了下地主，时不时问问到我了没有

I/O复用模型：

  • Java3y跟女朋友去麦当劳吃汉堡包，现在就厉害了可以使用微信小程序点餐了。于是跟女朋友找了个地方坐下就用小程序点餐了。点餐了之后玩玩斗地主、聊聊天什么的。时不时听到广播在复述XXX请取餐，反正我的单号还没到，就继续玩呗。~~等听到广播的时候再取餐就是了。时间过得挺快的，此时传来：Java3y请过来取餐。于是我就能拿到我的麦辣鸡翅汉堡了。
    • 听广播取餐，广播不是为我一个人服务。广播喊到我了，我过去取就Ok了。

四、使用NIO完成网络通信

4.1NIO基础继续讲解

回到我们最开始的图：

image

NIO被叫为 no-blocking io，其实是在网络这个层次中理解的，对于FileChannel来说一样是阻塞。

我们前面也仅仅讲解了FileChannel，对于我们网络通信是还有几个Channel的~

3N5JPvE.png

所以说：我们通常使用NIO是在网络中使用的，网上大部分讨论NIO都是在网络通信的基础之上的！说NIO是非阻塞的NIO也是网络中体现的！

从上面的图我们可以发现还有一个Selector选择器这么一个东东。从一开始我们就说过了，nio的核心要素有：

  • Buffer缓冲区
  • Channel通道
  • Selector选择器

我们在网络中使用NIO往往是I/O模型的多路复用模型！

  • Selector选择器就可以比喻成麦当劳的广播。
  • 一个线程能够管理多个Channel的状态
image

4.2NIO阻塞形态

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

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

客户端：


public class BlockClient {

    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("X:\\Users\\ozc\\Desktop\\新建文件夹\\1.png"), 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();
    }
}

服务端：


public class BlockServer {

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

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

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

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

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

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

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

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

            outChannel.write(buffer);

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

        }

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

结果就可以将客户端传递过来的图片保存在本地了：

lHcYwaD.png

此时服务端保存完图片想要告诉客户端已经收到图片啦：

DGavnUW.png

客户端接收服务端带过来的数据：

QMBXhyv.png

如果仅仅是上面的代码是不行的！这个程序会阻塞起来！

  • 因为服务端不知道客户端还有没有数据要发过来(与刚开始不一样，客户端发完数据就将流关闭了，服务端可以知道客户端没数据发过来了)，导致服务端一直在读取客户端发过来的数据。
  • 进而导致了阻塞！

于是客户端在写完数据给服务端时，显式告诉服务端已经发完数据了！

RtQQMHo.png

4.3NIO非阻塞形态

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

客户端：

public class NoBlockClient {

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

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

        // 1.1切换成非阻塞模式
        socketChannel.configureBlocking(false);

        // 2\. 发送一张图片给服务端吧
        FileChannel fileChannel = FileChannel.open(Paths.get("X:\\Users\\ozc\\Desktop\\新建文件夹\\1.png"), 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();
    }
}

服务端：


public class NoBlockServer {

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

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

        // 2.切换成非阻塞模式
        server.configureBlocking(false);

        // 3\. 绑定连接
        server.bind(new InetSocketAddress(6666));

        // 4\. 获取选择器
        Selector selector = Selector.open();

        // 4.1将通道注册到选择器上，指定接收“监听通道”事件
        server.register(selector, SelectionKey.OP_ACCEPT);

        // 5\. 轮训地获取选择器上已“就绪”的事件--->只要select()>0，说明已就绪
        while (selector.select() > 0) {
            // 6\. 获取当前选择器所有注册的“选择键”(已就绪的监听事件)
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

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

                SelectionKey selectionKey = iterator.next();

                // 接收事件就绪
                if (selectionKey.isAcceptable()) {

                    // 8\. 获取客户端的链接
                    SocketChannel client = server.accept();

                    // 8.1 切换成非阻塞状态
                    client.configureBlocking(false);

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

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

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

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

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

                    while (client.read(buffer) > 0) {
                        // 在读之前都要切换成读模式
                        buffer.flip();

                        outChannel.write(buffer);

                        // 读完切换成写模式，能让管道继续读取文件的数据
                        buffer.clear();
                    }
                }
                // 10\. 取消选择键(已经处理过的事件，就应该取消掉了)
                iterator.remove();
            }
        }

    }
}

还是刚才的需求：服务端保存了图片以后，告诉客户端已经收到图片了。

在服务端上只要在后面写些数据给客户端就好了：

image

在客户端上要想获取得到服务端的数据，也需要注册在register上(监听读事件)！


public class NoBlockClient2 {

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

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

        // 1.1切换成非阻塞模式
        socketChannel.configureBlocking(false);

        // 1.2获取选择器
        Selector selector = Selector.open();

        // 1.3将通道注册到选择器中，获取服务端返回的数据
        socketChannel.register(selector, SelectionKey.OP_READ);

        // 2\. 发送一张图片给服务端吧
        FileChannel fileChannel = FileChannel.open(Paths.get("X:\\Users\\ozc\\Desktop\\新建文件夹\\1.png"), 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\. 轮训地获取选择器上已“就绪”的事件--->只要select()>0，说明已就绪
        while (selector.select() > 0) {
            // 6\. 获取当前选择器所有注册的“选择键”(已就绪的监听事件)
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

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

                SelectionKey selectionKey = iterator.next();

                // 8\. 读事件就绪
                if (selectionKey.isReadable()) {

                    // 8.1得到对应的通道
                    SocketChannel channel = (SocketChannel) selectionKey.channel();

                    ByteBuffer responseBuffer = ByteBuffer.allocate(1024);

                    // 9\. 知道服务端要返回响应的数据给客户端，客户端在这里接收
                    int readBytes = channel.read(responseBuffer);

                    if (readBytes > 0) {
                        // 切换读模式
                        responseBuffer.flip();
                        System.out.println(new String(responseBuffer.array(), 0, readBytes));
                    }
                }

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

}

测试结果：

image

下面就简单总结一下使用NIO时的要点：

  • 将Socket通道注册到Selector中，监听感兴趣的事件
  • 当感兴趣的时间就绪时，则会进去我们处理的方法进行处理
  • 每处理完一次就绪事件，删除该选择键(因为我们已经处理完了)

4.4管道和DataGramChannel

这里我就不再讲述了，最难的TCP都讲了，UDP就很简单了。

UDP:

image
image

管道：

sOVDdJg.png
5nWtyKt.png

五、总结

总的来说NIO也是一个比较重要的知识点，因为它是学习netty的基础~

想以一篇来完全讲解NIO显然是不可能的啦，想要更加深入了解NIO可以往下面的链接继续学习~

参考资料：

如果文章有错的地方欢迎指正，大家互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y。为了大家方便，刚新建了一下qq群：742919422，大家也可以去交流交流。谢谢支持了！希望能多介绍给其他有需要的朋友

文章的目录导航：

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,378评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,356评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,702评论 0赞 342
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,259评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,263评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,036评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,349评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,979评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,469评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,938评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,059评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,703评论 4赞 323
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,257评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,262评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,485评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,501评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,792评论 2赞 345

推荐阅读更多精彩内容

  • NIO 教程（转）
    转自 http://www.ibm.com/developerworks/cn/education/java/j-...
    抓兔子的猫阅读 2,277评论 0赞 22
  • 攻破JAVA NIO技术壁垒
    原文链接 攻破JAVA NIO技术壁垒 现在使用NIO的场景越来越多，很多网上的技术框架或多或少的使用NIO技...
    阳光的技术小栈阅读 499评论 2赞 3
  • 撕裂着谎言
    为你我编织着 一个又一个的谎言 掩饰自己的脆弱 抵挡你的自责怜悯 用手艺和文字编织着自己规划的谎言 我赢了全世界却...
    潇筠阅读 214评论 0赞 2
  • 2018-04-26
    如果说西安是一个开始，那么从我双脚踏入这片土地的那一刻起，我就疯狂了······ 一直在思考大五的我该如何写，因为...
    别一种痛痒阅读 432评论 1赞 3