Java NIO总结整理

旧城等待， 2022-05-19 00:24 216阅读 0赞

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

**Java NIO与IO的主要区别**

<table> 
 <tbody> 
  <tr> 
   <td style="width:191px;">IO</td> 
   <td>NIO</td> 
  </tr> 
  <tr> 
   <td style="width:191px;">面向流(Stream Oriented)</td> 
   <td>面向缓冲区(Buffer Oriented)</td> 
  </tr> 
  <tr> 
   <td style="width:191px;">阻塞IO(Blocking IO)</td> 
   <td>非阻塞IO(NonBlocking IO)</td> 
  </tr> 
  <tr> 
   <td style="width:191px;">(无)</td> 
   <td>选择器(Selectors)</td> 
  </tr> 
  <tr> 
   <td style="width:191px;"><strong><u>单向</u></strong>的管道（水管）</td> 
   <td><strong><u>双向</u></strong>的，（通道Channel）相当于铁路，用于连接，没有任何数据，需要（缓冲区Buffer）火车完成运输</td> 
  </tr> 
 </tbody> 
</table>

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

## **                                                           缓冲区** ##

*  缓冲区（Buffer）：一个用于特定基本数据类型的容器。由java.nio 包定义的，所有缓冲区都是Buffer 抽象类的子类。
 *  Java NIO中的Buffer主要用于与NIO通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。
 *  Buffer就像一个数组，可以保存多个相同类型的数据。根据数据类型不同(boolean 除外) ，有以下Buffer常用子类：
    
        1 ByteBuffer
        
        2 CharBuffer
        
        3 ShortBuffer
        
        4 IntBuffer
        
        5 LongBuffer
        
        6 FloatBuffer
        
        7 DoubleBuffer
    
    上述Buffer 类他们都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。都是通过如下方法获取一个Buffer对象：
    
        static XxxBuffer allocate(int capacity)
    
    创建一个容量为capacity 的XxxBuffer对象
 *  Buffer中的重要概念：

![70][]

容量(capacity)：表示Buffer最大数据容量，缓冲区容量不能为负，并且创建后不能更改。
    
    限制(limit)：第一个不应该读取或写入的数据的索引，即位于limit后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。
    
    位置(position)：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制。
    
    标记(mark)与重置(reset)：标记是一个索引，通过Buffer中的mark()方法指定Buffer中一个特定的position，之后可以通过调用reset()方法恢复到这个position.
    
    标记位置限制容量遵守以下不变式：0<=mark<=position<=limit<=capacit

/*
     * 一、缓冲区（Buffer）：在 Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
     * 
     * 根据数据类型不同（boolean 除外），提供了相应类型的缓冲区：
     * ByteBuffer
     * CharBuffer
     * ShortBuffer
     * IntBuffer
     * LongBuffer
     * FloatBuffer
     * DoubleBuffer
     * 
     * 上述缓冲区的管理方式几乎一致，通过 allocate() 获取缓冲区
     * 
     * 二、缓冲区存取数据的两个核心方法：
     * put() : 存入数据到缓冲区中
     * get() : 获取缓冲区中的数据
     * 
     * 三、缓冲区中的四个核心属性：
     * capacity : 容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。
     * limit : 界限，表示缓冲区中可以操作数据的大小。（limit 后数据不能进行读写）
     * position : 位置，表示缓冲区中正在操作数据的位置。
     * 
     * mark : 标记，表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置
     * 
     * 0 <= mark <= position <= limit <= capacity
     * 
     * 四、直接缓冲区与非直接缓冲区：
     * 非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中
     * 直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率
     */
    public class TestBuffer {
    	
    	@Test
    	public void test3(){
    		//分配直接缓冲区
    		ByteBuffer buf = ByteBuffer.allocateDirect(1024);
    		
    		System.out.println(buf.isDirect());
    	}
    	
    	@Test
    	public void test2(){
    		String str = "abcde";
    		
    		ByteBuffer buf = ByteBuffer.allocate(1024);
    		
    		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));
    		System.out.println(buf.position());
    		
    		//mark() : 标记
    		buf.mark();
    		
    		buf.get(dst, 2, 2);
    		System.out.println(new String(dst, 2, 2));
    		System.out.println(buf.position());
    		
    		//reset() : 恢复到 mark 的位置
    		buf.reset();
    		System.out.println(buf.position());
    		
    		//判断缓冲区中是否还有剩余数据
    		if(buf.hasRemaining()){
    			
    			//获取缓冲区中可以操作的数量
    			System.out.println(buf.remaining());
    		}
    	}
    	
    	@Test
    	public void test1(){
    		String str = "abcde";
    		
    		//1. 分配一个指定大小的缓冲区
    		ByteBuffer buf = ByteBuffer.allocate(1024);
    		
    		System.out.println("-----------------allocate()----------------");
    		System.out.println(buf.position());
    		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());
    		System.out.println(buf.limit());
    		System.out.println(buf.capacity());
    		
    		//3. 切换读取数据模式
    		buf.flip();
    		
    		System.out.println("-----------------flip()----------------");
    		System.out.println(buf.position());
    		System.out.println(buf.limit());
    		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());
    		System.out.println(buf.limit());
    		System.out.println(buf.capacity());
    		
    		//5. rewind() : 可重复读
    		buf.rewind();
    		
    		System.out.println("-----------------rewind()----------------");
    		System.out.println(buf.position());
    		System.out.println(buf.limit());
    		System.out.println(buf.capacity());
    		
    		//6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态
    		buf.clear();
    		
    		System.out.println("-----------------clear()----------------");
    		System.out.println(buf.position());
    		System.out.println(buf.limit());
    		System.out.println(buf.capacity());
    		
    		System.out.println((char)buf.get());
    		
    	}
    
    }

*  Buffer的常用方法
    
    <table> 
     <tbody> 
      <tr> 
       <td>Buffer clear()</td> 
       <td style="width:639px;">清空缓冲区并返回对缓冲区的引用</td> 
      </tr> 
      <tr> 
       <td>Buffer flip()</td> 
       <td style="width:639px;">将缓冲区的界限设置为当前位置，并将当前位置充值为0</td> 
      </tr> 
      <tr> 
       <td>int capacity()</td> 
       <td style="width:639px;">返回Buffer的capacity大小</td> 
      </tr> 
      <tr> 
       <td>boolean hasRemaining()</td> 
       <td style="width:639px;">判断缓冲区中是否还有元素</td> 
      </tr> 
      <tr> 
       <td>int limit()</td> 
       <td style="width:639px;">返回Buffer 的界限(limit)&nbsp;的位置</td> 
      </tr> 
      <tr> 
       <td>Buffer limit(int n)</td> 
       <td style="width:639px;">将设置缓冲区界限为n,&nbsp;并返回一个具有新limit&nbsp;的缓冲区对象</td> 
      </tr> 
      <tr> 
       <td>Buffer mark()</td> 
       <td style="width:639px;">对缓冲区设置标记</td> 
      </tr> 
      <tr> 
       <td>int position()</td> 
       <td style="width:639px;">返回缓冲区的当前位置position</td> 
      </tr> 
      <tr> 
       <td>Buffer position(int n)</td> 
       <td style="width:639px;">将设置缓冲区的当前位置为n , 并返回修改后的Buffer&nbsp;对象</td> 
      </tr> 
      <tr> 
       <td>int remaining()</td> 
       <td style="width:639px;">返回position&nbsp;和limit&nbsp;之间的元素个数</td> 
      </tr> 
      <tr> 
       <td>Buffer reset()</td> 
       <td style="width:639px;">将位置position&nbsp;转到以前设置的mark&nbsp;所在的位置</td> 
      </tr> 
      <tr> 
       <td>Buffer rewind()</td> 
       <td style="width:639px;"> <p>将位置设为为0，取消设置的mark</p> </td> 
      </tr> 
     </tbody> 
    </table>
    
     
 *  缓冲区的数据操作:Buffer所有子类提供了两个用于数据操作的方法：get()与put()方法

**获取Buffer中的数据**

get()：读取单个字节

get(byte\[\] dst)：批量读取多个字节到dst中

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

**放入数据到Buffer中**

put(byte b)：将给定单个字节写入缓冲区的当前位置

put(byte\[\] src)：将src中的字节写入缓冲区的当前位置

put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动position)

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

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

##                                                             **通道** ##

*  **通道（Channel）**：由java.nio.channels包定义的。Channel表示IO源与目标打开的连接。Channel类似于传统的“流”。只不过Channel本身不能直接访问数据，Channel只能与Buffer进行交互。它是个独立的处理器，专门用于IO操作。
 *  Java 为Channel 接口提供的最主要实现类如下：  
    **    FileChannel**：用于读取、写入、映射和操作文件的通道。（用于本地文件操作）  
    **    DatagramChannel**：通过UDP 读写网络中的数据通道。  
    **    SocketChannel**：通过TCP 读写网络中的数据。  
    **    ServerSocketChannel**：可以监听新进来的TCP 连接，对每一个新进来的连接都会创建一个SocketChannel。
 *  获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下：  
    **FileInputStream（本地）  
    FileOutputStream（本地）  
    RandomAccessFile（本地）  
    DatagramSocket（网络）  
    Socket（网络）  
    ServerSocket（网络）**  
    获取通道的其他方式是使用Files 类的静态方法newByteChannel() 获取字节通道。或者通过通道的静态方法open() 打开并返回指定通道。
    
        /*
         * 一、通道（Channel）：用于源节点与目标节点的连接。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据，因此需要配合缓冲区进行传输。
         * 
         * 二、通道的主要实现类
         * 	java.nio.channels.Channel 接口：
         * 		|--FileChannel
         * 		|--SocketChannel
         * 		|--ServerSocketChannel
         * 		|--DatagramChannel
         * 
         * 三、获取通道
         * 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()
         * 
         * 四、通道之间的数据传输
         * transferFrom()
         * transferTo()
         * 
         * 五、分散(Scatter)与聚集(Gather)
         * 分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中
         * 聚集写入（Gathering Writes）：将多个缓冲区中的数据聚集到通道中
         * 
         * 六、字符集：Charset
         * 编码：字符串 -> 字节数组
         * 解码：字节数组  -> 字符串
         * 
         */
        public class TestChannel {
        	
        	//字符集
        	@Test
        	public void test6() throws IOException{
        		Charset cs1 = Charset.forName("GBK");
        		
        		//获取编码器
        		CharsetEncoder ce = cs1.newEncoder();
        		
        		//获取解码器
        		CharsetDecoder cd = cs1.newDecoder();
        		
        		CharBuffer cBuf = CharBuffer.allocate(1024);
        		cBuf.put("尚硅谷威武！");
        		cBuf.flip();
        		
        		//编码
        		ByteBuffer bBuf = ce.encode(cBuf);
        		
        		for (int i = 0; i < 12; 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("GBK");
        		bBuf.flip();
        		CharBuffer cBuf3 = cs2.decode(bBuf);
        		System.out.println(cBuf3.toString());
        	}
        	
        	@Test
        	public void test5(){
        		Map<String, Charset> map = Charset.availableCharsets();
        		
        		Set<Entry<String, Charset>> set = map.entrySet();
        		
        		for (Entry<String, Charset> entry : set) {
        			System.out.println(entry.getKey() + "=" + entry.getValue());
        		}
        	}
        	
        	//分散和聚集
        	@Test
        	public void test4() throws IOException{
        		RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");
        		
        		//1. 获取通道
        		FileChannel channel1 = raf1.getChannel();
        		
        		//2. 分配指定大小的缓冲区
        		ByteBuffer buf1 = ByteBuffer.allocate(100);
        		ByteBuffer buf2 = ByteBuffer.allocate(1024);
        		
        		//3. 分散读取
        		ByteBuffer[] bufs = {buf1, buf2};
        		channel1.read(bufs);
        		
        		for (ByteBuffer byteBuffer : bufs) {
        			byteBuffer.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. 聚集写入
        		RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
        		FileChannel channel2 = raf2.getChannel();
        		
        		channel2.write(bufs);
        	}
        	
        	//通道之间的数据传输(直接缓冲区)
        	@Test
        	public void test3() throws IOException{
        		FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
        		FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
        		
        //		inChannel.transferTo(0, inChannel.size(), outChannel);
        		outChannel.transferFrom(inChannel, 0, inChannel.size());
        		
        		inChannel.close();
        		outChannel.close();
        	}
        	
        	//使用直接缓冲区完成文件的复制(内存映射文件)
        	@Test
        	public void test2() throws IOException{//2127-1902-1777
        		long start = System.currentTimeMillis();
        		
        		FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
        		FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
        		
        		//内存映射文件
        		MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
        		MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
        		
        		//直接对缓冲区进行数据的读写操作
        		byte[] dst = new byte[inMappedBuf.limit()];
        		inMappedBuf.get(dst);
        		outMappedBuf.put(dst);
        		
        		inChannel.close();
        		outChannel.close();
        		
        		long end = System.currentTimeMillis();
        		System.out.println("耗费时间为：" + (end - start));
        	}
        	
        	//利用通道完成文件的复制（非直接缓冲区）
        	@Test
        	public void test1(){//10874-10953
        		long start = System.currentTimeMillis();
        		
        		FileInputStream fis = null;
        		FileOutputStream fos = null;
        		//①获取通道
        		FileChannel inChannel = null;
        		FileChannel outChannel = null;
        		try {
        			fis = new FileInputStream("d:/1.mkv");
        			fos = new FileOutputStream("d:/2.mkv");
        			
        			inChannel = fis.getChannel();
        			outChannel = fos.getChannel();
        			
        			//②分配指定大小的缓冲区
        			ByteBuffer buf = ByteBuffer.allocate(1024);
        			
        			//③将通道中的数据存入缓冲区中
        			while(inChannel.read(buf) != -1){
        				buf.flip(); //切换读取数据的模式
        				//④将缓冲区中的数据写入通道中
        				outChannel.write(buf);
        				buf.clear(); //清空缓冲区
        			}
        		} catch (IOException e) {
        			e.printStackTrace();
        		} finally {
        			if(outChannel != null){
        				try {
        					outChannel.close();
        				} catch (IOException e) {
        					e.printStackTrace();
        				}
        			}
        			
        			if(inChannel != null){
        				try {
        					inChannel.close();
        				} catch (IOException e) {
        					e.printStackTrace();
        				}
        			}
        			
        			if(fos != null){
        				try {
        					fos.close();
        				} catch (IOException e) {
        					e.printStackTrace();
        				}
        			}
        			
        			if(fis != null){
        				try {
        					fis.close();
        				} catch (IOException e) {
        					e.printStackTrace();
        				}
        			}
        		}
        		
        		long end = System.currentTimeMillis();
        		System.out.println("耗费时间为：" + (end - start));
        		
        	}
        
        }
    
    ## **                                 NIO的非阻塞式网络通信** ##
 *  **传统的IO** 流都是阻塞式的。也就是说，当一个线程调用read() 或write() 时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。
 *  **Java NIO** 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞IO 的空闲时间用于在其他通道上执行IO 操作，所以单独的线程可以管理多个输入和输出通道。因此，NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。
 *  **选择器（Selector）**是SelectableChannle 对象的多路复用器，Selector 可以同时监控多个SelectableChannel 的IO 状况，也就是说，利用Selector 可使一个单独的线程管理多个Channel。Selector 是非阻塞IO 的核心。
    
        /*
         * 一、使用 NIO 完成网络通信的三个核心：
         * 
         * 1. 通道（Channel）：负责连接
         * 		
         * 	   java.nio.channels.Channel 接口：
         * 			|--SelectableChannel
         * 				|--SocketChannel
         * 				|--ServerSocketChannel
         * 				|--DatagramChannel
         * 
         * 				|--Pipe.SinkChannel
         * 				|--Pipe.SourceChannel
         * 
         * 2. 缓冲区（Buffer）：负责数据的存取
         * 
         * 3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况
         * 
         */
        public class TestBlockingNIO {
        
        	//客户端
        	@Test
        	public void client() throws IOException{
        		//1. 获取通道
        		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        		
        		FileChannel 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();
        		}
        		
        		//4. 关闭通道
        		inChannel.close();
        		sChannel.close();
        	}
        	
        	//服务端
        	@Test
        	public void server() throws IOException{
        		//1. 获取通道
        		ServerSocketChannel ssChannel = ServerSocketChannel.open();
        		
        		FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        		
        		//2. 绑定连接
        		ssChannel.bind(new InetSocketAddress(9898));
        		
        		//3. 获取客户端连接的通道
        		SocketChannel sChannel = ssChannel.accept();
        		
        		//4. 分配指定大小的缓冲区
        		ByteBuffer buf = ByteBuffer.allocate(1024);
        		
        		//5. 接收客户端的数据，并保存到本地
        		while(sChannel.read(buf) != -1){
        			buf.flip();
        			outChannel.write(buf);
        			buf.clear();
        		}
        		
        		//6. 关闭通道
        		sChannel.close();
        		outChannel.close();
        		ssChannel.close();
        		
        	}
        	
        }
    
        public class TestBlockingNIO2 {
        	
        	//客户端
        	@Test
        	public void client() throws IOException{
        		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        		
        		FileChannel 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();
        		}
        		
        		inChannel.close();
        		sChannel.close();
        	}
        	
        	//服务端
        	@Test
        	public void server() throws IOException{
        		ServerSocketChannel ssChannel = ServerSocketChannel.open();
        		
        		FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        		
        		ssChannel.bind(new InetSocketAddress(9898));
        		
        		SocketChannel 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);
        		
        		sChannel.close();
        		outChannel.close();
        		ssChannel.close();
        	}
        
        }
    
        /*
         * 一、使用 NIO 完成网络通信的三个核心：
         * 
         * 1. 通道（Channel）：负责连接
         * 		
         * 	   java.nio.channels.Channel 接口：
         * 			|--SelectableChannel
         * 				|--SocketChannel
         * 				|--ServerSocketChannel
         * 				|--DatagramChannel
         * 
         * 				|--Pipe.SinkChannel
         * 				|--Pipe.SourceChannel
         * 
         * 2. 缓冲区（Buffer）：负责数据的存取
         * 
         * 3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况
         * 
         */
        public class TestNonBlockingNIO {
        	
        	//客户端
        	@Test
        	public void client() throws IOException{
        		//1. 获取通道
        		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        		
        		//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();
        		}
        		
        		//5. 关闭通道
        		sChannel.close();
        	}
        
        	//服务端
        	@Test
        	public void server() throws IOException{
        		//1. 获取通道
        		ServerSocketChannel ssChannel = ServerSocketChannel.open();
        		
        		//2. 切换非阻塞模式
        		ssChannel.configureBlocking(false);
        		
        		//3. 绑定连接
        		ssChannel.bind(new InetSocketAddress(9898));
        		
        		//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;
        					while((len = sChannel.read(buf)) > 0 ){
        						buf.flip();
        						System.out.println(new String(buf.array(), 0, len));
        						buf.clear();
        					}
        				}
        				
        				//15. 取消选择键 SelectionKey
        				it.remove();
        			}
        		}
        	}
        }

*整理自尚硅谷视频*

[70]: /images/20220519/bff6d58151ca46b59ded1edf162ab07d.png