衣带渐宽终不悔。为伊消得人憔悴。

——柳永《蝶恋花》

Java NIO

1. Java NIO 简介

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

2. Java NIO 与 IO 的主要区别

IO NIO
面向流(Stream Oriented) 面向缓冲区(Buffer Oriented)
阻塞IO(Blocking IO) 非阻塞IO(Non Blocking IO)
(无) 选择器(Selectors)

3. 缓冲区(Buffer)和通道(Channel)

Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开到IO 设备(例如：文件、套接字)的连接。若需要使用NIO 系统，需要获取用于连接IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。

==简而言之，Channel 负责传输，Buffer 负责存储。==

3.1 缓冲区(Buffer)

  • 缓冲区（Buffer）：一个用于特定基本数据类型的容器。由java.nio 包定义的，所有缓冲区都是Buffer 抽象类的子类。

  • Java NIO 中的Buffer 主要用于与NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。

  • Buffer 就像一个数组，可以保存多个相同类型的数据。根据数据类型不同(boolean 除外) ，有以下Buffer 常用子类：

    • ByteBuffer
    • ShortBuffer
    • IntBuffer
    • LongBuffer
    • FloatBuffer
    • DoubleBuffer
    • CharBuffer
    • image-20201108211255554

  • 上述Buffer 类他们都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。都是通过如下方法获取一个Buffer 对象：public static XxxBuffer allocate(int capacity) : 创建一个容量为capacity 的XxxBuffer 对象，具体如下：

  •     public static IntBuffer allocate(int capacity) {
        if (capacity < 0)
            throw new IllegalArgumentException();
        return new HeapIntBuffer(capacity, capacity);
    }
缓冲区的基本属性

Buffer 中的重要概念：

  • 容量(capacity) ： 表示缓冲区中最大存储数据的容量。一旦声明不能改变。
  • 限制(limit)：表示缓冲区中可以操作数据的大小。（limit 后数据不能进行读写）
  • 位置(position)：表示缓冲区中正在操作数据的位置。
  • 标记(mark)：表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置。
  • 标记、位置、限制、容量遵守以下不变式： 0 <= mark <= position <= limit <= capacity

image-20201108220146505

缓冲区存取数据的两个核心方法
  • put() : 存入数据到缓冲区中
    • put(byte b)：将给定单个字节写入缓冲区的当前位置。
    • put(byte[] src)：将src 中的字节写入缓冲区的当前位置。
    • put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动position)。
  • get() : 获取缓冲区中的数据
    • get() ：读取单个字节。
    • get(byte[] dst)：批量读取多个字节到dst 中。
    • get(int index)：读取指定索引位置的字节(不会移动position)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package cn.justweb;

import org.junit.Test;

import java.nio.ByteBuffer;

/**
 * @Date 2020/11/8 21:21
 * @Version 10.21
 * @Author DuanChaojie
 */
public class BufferTest {

    @Test
    public void test1(){
        String str = "abcde";
        //1. 分配一个指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);

        System.out.println("-----------------allocate()----------------");
        System.out.println(buf.position());// 0
        System.out.println(buf.limit());
        System.out.println(buf.capacity());

        //2. 利用 put() 存入数据到缓冲区中
        buf.put(str.getBytes());

        System.out.println("-----------------put()----------------");
        System.out.println(buf.position());// 5
        System.out.println(buf.limit());
        System.out.println(buf.capacity());

        //3. 切换读取数据模式
        buf.flip();
        System.out.println("-----------------flip()----------------");
        System.out.println(buf.position());// 0
        System.out.println(buf.limit());// 5
        System.out.println(buf.capacity());

        //4. 利用 get() 读取缓冲区中的数据
        byte[] dst = new byte[buf.limit()];
        buf.get(dst);
        System.out.println(new String(dst, 0, dst.length));

        System.out.println("-----------------get()----------------");
        System.out.println(buf.position());// 5
        System.out.println(buf.limit());// 5
        System.out.println(buf.capacity());

        //5. rewind() : 可重复读
        buf.rewind();

        System.out.println("-----------------rewind()----------------");
        System.out.println(buf.position());// 0
        System.out.println(buf.limit());// 5
        System.out.println(buf.capacity());

        //6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态
        buf.clear();

        System.out.println("-----------------clear()----------------");
        System.out.println(buf.position());// 0
        System.out.println(buf.limit());// 1024
        System.out.println(buf.capacity());// 1024

        // 还可以读取到 a
        System.out.println((char)buf.get());
    }

    @Test
    public void test2(){
        String str = "abcde";
        // 分配一个指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 利用 put() 存入数据到缓冲区中
        buf.put(str.getBytes());
        // 切换读取数据模式
        buf.flip();
        byte[] dst = new byte[buf.limit()];
        buf.get(dst,0,2);

        System.out.println(new String(dst,0,2));// ab
        System.out.println(buf.position());// 2

        //mark():标记
        buf.mark();

        buf.get(dst,2,2);

        System.out.println(new String(dst,2,2));// cd

        System.out.println(buf.position());// 4
        // reset() ：恢复mark的位置
        buf.reset();
        System.out.println(buf.position());// 2
        
        //判断缓冲区中是否还有剩余数据
        if(buf.hasRemaining()){
            //获取缓冲区中可以操作的数量
            System.out.println(buf.remaining());
        }    

    }
}

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

  • 非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中。

    • image-20201108224335686

    • ~~~java

      public static ByteBuffer allocate(int capacity) {
    if (capacity < 0)
        throw new IllegalArgumentException();
    return new HeapByteBuffer(capacity, capacity);
}

      1
      2
      3
      4
      5
      6
      7
      8
      9

      * 直接缓冲区：`通过 allocateDirect() 方法分配直接缓冲区`，将缓冲区建立在物理内存中。可以提高效率。

        - ![image-20201108224427560](https://oss-blogs.oss-cn-hangzhou.aliyuncs.com/blogs/itbuild/JavaSE-IO流/image-20201108224427560.png)

        - ~~~java
              public static ByteBuffer allocateDirect(int capacity) {
                  return new DirectByteBuffer(capacity);
              }
1
2
3
4
5
6
7
8
9
10
public class TestBuffer {
	
	@Test
	public void test3(){
		//分配直接缓冲区
		ByteBuffer buf = ByteBuffer.allocateDirect(1024);
		
		System.out.println(buf.isDirect());//true
	}
}
  • 字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则Java 虚拟机会尽最大努力直接在此缓冲区上执行本机I/O 操作。也就是说，在每次调用基础操作系统的一个本机I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。
  • ☆直接字节缓冲区可以通过调用此类的allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。
  • ☆直接字节缓冲区还可以通过FileChannel 的map() 方法将文件区域直接映射到内存中来创建。该方法返回MappedByteBuffer 。Java 平台的实现有助于通过JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。
  • 字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其isDirect() 方法来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。

3.2 通道(Channel)

通道（Channel）：由java.nio.channels 包定义的。Channel 表示IO 源与目标打开的连接。 Channel 类似于传统的“流”。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据，因此需要配合缓冲区进行传输。

image-20201109112102245

  1. 什么是DMA
  2. DMA 和 Channel 的区别

image-20201109112111503

Channel 接口的最主要实现类

java.nio.channels.Channel 接口：

  • FileChannel：用于读取、写入、映射和操作文件的通道。
  • DatagramChannel：通过 UDP 读写网络中的数据通道。
  • SocketChannel：通过 TCP 读写网络中的数据。
  • ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的链接都会创建一个SocketChannel。
获取通道的三种方式

  1. Java 针对支持通道的类提供了 getChannel() 方法。

    • 本地 IO：
      • FileInputStream/FileOutputStream
      • RandomAccessFile
    • 网络IO：
      • Socket
      • ServerSocket
      • DatagramSocket

  2. 在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open()。

  3. 在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()。

通道之间的数据传输☆
  1. image-20201109113302447
  2. image-20201109113312395
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
/**
 * 利用通道完成文件的复制（非直接缓冲区）
 */
@Test
public void test1(){
    long start = System.currentTimeMillis();

    FileInputStream fis = null;
    FileOutputStream fos = null;
    FileChannel inChannel = null;
    FileChannel outChannel = null;
    try {

        fis = new FileInputStream("E:\\file\\1988第一段.mp4");
        fos = new FileOutputStream("E:\\file\\1988-copy1.mp4");
        inChannel = fis.getChannel();
        outChannel = fos.getChannel();

        // 1、分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        
        // 2、将通道中的数据存入缓冲区
        while(inChannel.read(buf) != -1){
            // 切换读取数据模式
            buf.flip();
            // 将缓冲区中的数据写入通道中
            outChannel.write(buf);
            // 清空缓冲区
            buf.clear();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        // 关闭流资源，先开后关
        try {
            outChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            inChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


@Test
public void test2(){
    long start = 0;
    long end = 0;
    FileChannel inChannel = null;
    FileChannel outChannel = null;
    MappedByteBuffer inMappedBuf = null;
    MappedByteBuffer outMappedBuf = null;

    try {
        start = System.currentTimeMillis();

        inChannel = FileChannel.open(Paths.get("E:\\file\\1988第一段.mp4"), StandardOpenOption.READ);
        outChannel = FileChannel.open(Paths.get("E:\\file\\1988-copy2.mp4"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);

        // 内存映射文件
        inMappedBuf = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
        outMappedBuf = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());

        // 直接缓冲区进行数据读写操作
        byte[] dst = new byte[inMappedBuf.limit()];
        inMappedBuf.get(dst);
        outMappedBuf.put(dst);



    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            inChannel.close();
            outChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        end = System.currentTimeMillis();
        System.out.println("耗费时间为：" + (end - start));
    }
}

分散(Scatter)与聚集(Gather)

  • 分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中。
    • image-20201109114159944
  • 聚集写入（Gathering Writes）：将多个缓冲区中的数据聚集到通道中。
    • image-20201109114136231
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/**
 * 分散和聚集
 */
@Test
public void test4(){
    RandomAccessFile raf1 = null;
    RandomAccessFile raf2= null;
    FileChannel channel1 = null;
    FileChannel channel2 = null;
    try {
        raf1 = new RandomAccessFile("1.txt", "rw");
        // 1.获取通道
        channel1 = raf1.getChannel();
        // 2.分配制定大小的缓冲区
        ByteBuffer buf1 = ByteBuffer.allocate(100);
        ByteBuffer buf2 = ByteBuffer.allocate(1024);

        // 3.分散读取
        ByteBuffer[] bufs = {buf1,buf2};
        channel1.read(bufs);

        for (ByteBuffer buf : bufs) {
            buf.flip();
        }
        System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));
        System.out.println("---------------------------------------------");
        System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));

        // 4.聚集写入
        raf2 = new RandomAccessFile("2.txt", "rw");
        channel2 = raf2.getChannel();
        channel2.write(bufs);
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            channel2.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            raf2.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            channel1.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            raf1.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

transferFrom()和transferTo()

  • transferFrom() 将数据从源通道传输到其他 Channel 中。
  • image-20201109114732130
  • transferTo() 将数据从源通道传输到其他 Channel 中。
  • image-20201109114741147
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
  * 通道之间的数据传输(直接缓冲区)
  */
 @Test
 public void test3(){
     FileChannel inChannel = null;
     FileChannel outChannel = null;
     try {
         inChannel = FileChannel.open(Paths.get("E:\\file\\1988第一段.mp4"), StandardOpenOption.READ);
         outChannel = FileChannel.open(Paths.get("E:\\file\\1988-copy3.mp4"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
         //inChannel.transferTo(0,inChannel.size(),outChannel);
         outChannel.transferFrom(inChannel,0,inChannel.size());

     } catch (IOException e) {
         e.printStackTrace();
     }finally {
         try {
             inChannel.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
         try {
             outChannel.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

字符集：Charset

  • 编码：字符串 -> 字节数组
  • 解码：字节数组 -> 字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/**
 * Charset
 */
@Test
public void test5(){
    try {
        Charset cs1 = Charset.forName("GBK");
        // 获取编码器
        CharsetEncoder ce = cs1.newEncoder();
        // 获取解码器
        CharsetDecoder cd = cs1.newDecoder();
        
        // 创建缓冲区
        CharBuffer cBuf = CharBuffer.allocate(1024);
        cBuf.put("Justweb程序员");
        cBuf.flip();
        
        // 编码
        ByteBuffer bBuf = ce.encode(cBuf);
        for (int i = 0; i < 13; i++) {
            System.out.println(bBuf.get());
        }

        // 解码
        bBuf.flip();
        CharBuffer cBuf2 = cd.decode(bBuf);
        System.out.println(cBuf2.toString());
        System.out.println("----------------------------");
        
        Charset cs2 = Charset.forName("UTF-8");
        bBuf.flip();
        CharBuffer cBuf3 = cs2.decode(bBuf);
        System.out.println(cBuf3.toString());

    } catch (CharacterCodingException e) {
        e.printStackTrace();
    }
}
FileChannel 的常用方法

image-20201109114921208

4. NIO 的非阻塞式网络通信

4.1 阻塞与非阻塞

  1. 传统的IO 流都是阻塞式的。也就是说，当一个线程调用read() 或write()时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。
  2. Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞IO 的空闲时间用于在其他通道上执行IO 操作，所以单独的线程可以管理多个输入和输出通道。因此，NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。
  3. feizuse
    • 比阻塞模式多了个Selector。
SocketChannel
  1. Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。
  2. 操作步骤：
    • 打开SocketChannel
    • 读写数据
    • 关闭SocketChannel
  3. Java NIO中的ServerSocketChannel 是一个可以监听新进来的TCP连接的通道，就像标准IO中的ServerSocket一样。
DatagramChannel
  1. Java NIO中的DatagramChannel是一个能收发UDP包的通道。
  2. 操作步骤：
    • 打开DatagramChannel
    • 接收/发送数据
阻塞模式

  1. 使用 NIO 完成网络通信的三个核心：

    1. 通道（Channel）：负责连接

      • java.nio.channels.Channel 接口：

        ​ |–SelectableChannel

        ​ |–SocketChannel

        ​ |–ServerSocketChannel

        ​ |–DatagramChannel

        ​ |–Pipe.SinkChannel

        ​ |–Pipe.SourceChannel

    2. 缓冲区（Buffer）：负责数据的存取。

    3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况。

  2. Java中InetAddress与InetSocketAddress的基本用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package cn.justweb;

import org.junit.Test;

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;

/**
 * @Date 2020/11/9 21:17
 * @Version 10.21
 * @Author DuanChaojie
 * 先运行server再运行client
 */
public class BlockingNIOTest {
    /**
     * 客户端
     */
    @Test
    public void client(){
        SocketChannel sChannel = null;
        FileChannel inChannel = null;
        try {
            // 1.获取通道
            sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 1021));
            inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);

            // 2.分配指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);

            // 3.读取本地文件，并发送到服务端
            while (inChannel.read(buf) != -1){
                buf.flip();
                sChannel.write(buf);
                buf.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            // 4.关闭通道
            try {
                inChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                sChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 服务端
     */
    @Test
    public void server(){
        ServerSocketChannel ssChannel = null;
        FileChannel outChannel = null;
        SocketChannel sChannel = null;
        try {
            // 1.获取通道
            ssChannel = ServerSocketChannel.open();
            outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

            // 2.绑定链接
            ssChannel.bind(new InetSocketAddress(1021));
            
            // 3.获取客户端连接的通道
            sChannel = ssChannel.accept();
            
            // 4.分配指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);
            // 5.接收客户端的数据，并保存到本地
            while(sChannel.read(buf) != -1){
                buf.flip();
                outChannel.write(buf);
                buf.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            // 6.关闭通道
            try {
                sChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                outChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                ssChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

BlockingNIO2Test:完成阻塞时双向通信。

  • sChannel.shutdownOutput();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package cn.justweb;


import org.junit.Test;

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;

/**
 * @Date 2020/11/9 21:50
 * @Version 10.21
 * @Author DuanChaojie
 */
public class BlockingNIO2Test {

    @Test
    public void client() {
        SocketChannel sChannel = null;
        FileChannel inChannel = null;
        try {
            sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 1021));
            inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
            ByteBuffer buf = ByteBuffer.allocate(1024);
            while (inChannel.read(buf) != -1) {
                buf.flip();
                sChannel.write(buf);
                buf.clear();
            }
            
            sChannel.shutdownOutput();
            
            // 接收服务端的反馈
            int len = 0;
            while ((len = sChannel.read(buf)) != -1) {
                
                buf.flip();
                System.out.println(new String(buf.array(), 0, len));
                buf.clear();
              
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                inChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                sChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void server() {
        ServerSocketChannel ssChannel = null;
        FileChannel outChannel = null;
        SocketChannel sChannel = null;
        try {
            ssChannel = ServerSocketChannel.open();

            outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

            ssChannel.bind(new InetSocketAddress(1021));

            sChannel = ssChannel.accept();

            ByteBuffer buf = ByteBuffer.allocate(1024);

            while (sChannel.read(buf) != -1) {
                buf.flip();
                outChannel.write(buf);
                buf.clear();
            }
            // 发送反馈给客户端
            buf.put("服务端接收数据成功".getBytes());
            buf.flip();
            sChannel.write(buf);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                sChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                outChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                ssChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

非阻塞模式

解决junit测试的时候,不能在控制台进行输入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package cn.justweb;

import org.junit.Test;

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

import java.util.Date;
import java.util.Iterator;
import java.util.Scanner;

/**
 * @Date 2020/11/9 22:21
 * @Version 10.21
 * @Author DuanChaojie
 */
public class NonBlockingNIOTest {

    @Test
    public void client() {
        SocketChannel sChannel = null;
        try {
            // 1.获取通道
            sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 1021));

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

            // 3.分配指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);

            // 4.发送数据给服务端
            Scanner scan = new Scanner(System.in);
            while (scan.hasNext()) {
                String str = scan.next();
                buf.put((new Date().toString() + "\n" + str).getBytes());
                buf.flip();
                sChannel.write(buf);
                buf.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 5.关闭通道
            try {
                sChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void server() {
        ServerSocketChannel ssChannel = null;
        try {
            // 1.获取通道
            ssChannel = ServerSocketChannel.open();
            // 2.切换非阻塞模式
            ssChannel.configureBlocking(false);

            // 3.绑定链接
            ssChannel.bind(new InetSocketAddress(1021));

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

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

            // 6.轮询式的获取选择器上已经“准备就绪”的事件
            while (selector.select() > 0) {
                // 7.获取当前选择器中所有注册的“选择键（已就绪的监听事件）”
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();

                while (it.hasNext()) {
                    // 8.获取准备“就绪”的事件
                    SelectionKey sk = it.next();
                    // 9.判断具体是什么事件准备就绪
                    if (sk.isAcceptable()) {
                        // 10.若“接收就绪”，获取客户端连接
                        SocketChannel sChannel = ssChannel.accept();

                        // 11.切换非阻塞模式
                        sChannel.configureBlocking(false);

                        // 12.将该通道注册到选择器上
                        sChannel.register(selector, SelectionKey.OP_READ);
                    } else if (sk.isReadable()) {

                        // 13.获取当前选择器上“读就绪”状态的通道
                        SocketChannel sChannel = (SocketChannel) sk.channel();

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

                        int len = 0;
                        ///// 这个地方为什么是大于0
                        while ((len = sChannel.read(buf)) > 0) {
                            buf.flip();
                            System.out.println(new String(buf.array(), 0, len));
                            buf.clear();
                        }
                    }

                    // 15.取消选择键 SelectionKey
                    it.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                ssChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

NonBlockingNIO2Test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package cn.justweb;

import org.junit.Test;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Date;
import java.util.Iterator;
import java.util.Scanner;

/**
 * @Date 2020/11/10 9:18
 * @Version 10.21
 * @Author DuanChaojie
 */
public class NonBlockingNIO2Test {

    @Test
    public void send() {
        DatagramChannel dc = null;
        try {
            dc = DatagramChannel.open();
            dc.configureBlocking(false);
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            Scanner scan = new Scanner(System.in);

            while (scan.hasNext()) {
                String str = scan.next();
                buffer.put((new Date() + "\n" + str).getBytes());
                buffer.flip();
                dc.send(buffer, new InetSocketAddress("127.0.0.1", 1021));
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                dc.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void receive() {
        DatagramChannel dc = null;
        try {
            dc = DatagramChannel.open();
            dc.configureBlocking(false);
            dc.bind(new InetSocketAddress(1021));
            Selector selector = Selector.open();
            dc.register(selector, SelectionKey.OP_READ);
            while (selector.select() > 0) {
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                while (it.hasNext()) {
                    SelectionKey sk = it.next();
                    if (sk.isReadable()) {
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        dc.receive(buffer);
                        buffer.flip();
                        System.out.println(new String(buffer.array(), 0, buffer.limit()));
                        buffer.clear();
                    }
                }
                it.remove();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.2 选择器（Selector）

  1. 选择器（Selector）是SelectableChannle 对象的多路复用器，Selector 可以同时监控多个SelectableChannel 的IO 状况，也就是说，利用Selector可使一个单独的线程管理多个Channel。Selector 是非阻塞IO 的核心。SelectableChannle 的结构如下图：
  2. image-20201110094923388
  3. 通过调用Selector.open() 方法创建一个Selector。
  4. 向选择器注册通道：SelectableChannel.register(Selector sel,int ops);当调用register(Selector sel, int ops) 将通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数ops 指定。
    • 可以监听的事件类型（可使用SelectionKey 的四个常量表示）：
      • 读: SelectionKey.OP_READ （1）
      • 写: SelectionKey.OP_WRITE （4）
      • 连接: SelectionKey.OP_CONNECT （8）
      • 接收: SelectionKey.OP_ACCEPT （16）
    • SelectionKey：表示SelectableChannel 和Selector 之间的注册关系。每次向选择器注册通道时就会选择一个事件(选择键)。选择键包含两个表示为整数值的操作集。操作集的每一位都表示该键的通道所支持的一类可选择操作。下面是SelectionKey的常用方法：
    • image-20201110095515168

image-20201110095619346

4.3 管道

Java NIO 管道是2个线程之间的单向数据连接。 Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。

image-20201110100559591

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
 * @Date 2020/11/10 9:35
 * @Version 10.21
 * @Author DuanChaojie
 */
public class PipeTest {

    @Test
    public void test() {
        Pipe.SinkChannel sinkChannel = null;
        Pipe.SourceChannel sourceChannel = null;
        try {
            // 1.获取管道
            Pipe pipe = Pipe.open();

            // 2.将缓冲区中的数据写入管道
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            sinkChannel = pipe.sink();
            buffer.put("通过单向通道发送数据".getBytes());
            buffer.flip();
            sinkChannel.write(buffer);

            // 3.读取缓冲区中的数据
            sourceChannel = pipe.source();
            buffer.flip();
            int len = sourceChannel.read(buffer);
            System.out.println(new String(buffer.array(), 0, len));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                sourceChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                sinkChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

5. NIO.2

随着JDK 7 的发布，Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为NIO.2。因为NIO 提供的一些功能，NIO已经成为文件处理中越来越重要的部分。

5.1 Path和Paths

  1. java.nio.file.Path 接口代表一个平台无关的平台路径，描述了目录结构中文件的位置。

  2. Paths 提供的get() 方法用来获取Path 对象：

    • Path get(String first, String … more) : 用于将多个字符串串连成路径。
  3. Path 常用方法：
    boolean endsWith(String path) : 判断是否以 path 路径结束
    boolean startsWith(String path) : 判断是否以 path 路径开始
    boolean isAbsolute() : 判断是否是绝对路径
    Path getFileName() : 返回与调用 Path 对象关联的文件名
    Path getName(int idx) : 返回的指定索引位置 idx 的路径名称
    int getNameCount() : 返回Path 根目录后面元素的数量
    Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
    Path getRoot() ：返回调用 Path 对象的根路径
    Path resolve(Path p) :将相对路径解析为绝对路径
    Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
    String toString() ： 返回调用 Path 对象的字符串表示形式

5.2 Files 类

  1. Java基础之File类
  2. java.nio.file.Files用于操作文件或目录的工具类。
  3. Files常用方法：
Path copy(Path src, Path dest, CopyOption … how) : 文件的复制
Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录
Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件
void delete(Path path) : 删除一个文件
Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置
long size(Path path) : 返回 path 指定文件的大小
  1. Files常用方法：用于判断
boolean exists(Path path, LinkOption … opts) : 判断文件是否存在
boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
boolean isExecutable(Path path) : 判断是否是可执行文件
boolean isHidden(Path path) : 判断是否是隐藏文件
boolean isReadable(Path path) : 判断文件是否可读
boolean isWritable(Path path) : 判断文件是否可写
boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在
public static A readAttributes(Path path,Class type,LinkOption… options) : 获取与 path 指定的文件相关联的属性。
  1. Files常用方法：用于操作内容
SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接，how 指定打开方式。
DirectoryStream newDirectoryStream(Path path) : 打开 path 指定的目录
InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象
OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象

5.3 自动资源管理

Java 7 增加了一个新特性，该特性提供了另外一种管理资源的方式，这种方式能自动关闭文件。这个特性有时被称为自动资源管理(Automatic Resource Management, ARM)，该特性以try 语句的扩展版为基础。自动资源管理主要用于，当不再需要文件（或其他资源）时，可以防止无意中忘记释放它们。

☆