Java NIO学习笔记

Java NIO学习笔记

一、Java NIO简介

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

二、Java NIO与IO的主要区别

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

三、缓冲区（Buffer）和通道（Channel）

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

1、缓冲区

• 在Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
• 根据数据类型的不同（boolean除外），提供了相应类型的缓冲区：
  • ByteBuffer
  • CharBuffer
  • ShortBuffer
  • IntBuffer
  • LongBuffer
  • FloatBuffer
  • DoubleBuffer
• 上述缓冲区的管理方式几乎一致，通过allocate()获得缓冲区。

缓冲区存取数据的两个核心方法：

• put()：存入数据到缓冲区中
  • put(byte b)：将给定单个字节写入缓冲区的当前位置
  • put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
  • put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position
• get()：获取缓冲区中的数据
  • get() ：读取单个字节
  • get(byte[] dst)：批量读取多个字节到 dst 中
  • get(int index)：读取指定索引位置的字节(不会移动 position)

缓冲区中的四个核心属性：

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

package com.hsw.nio;

import java.nio.ByteBuffer;

import org.junit.Test;

public class TestBuffer {
	@Test
	public void test1() {
		String str = "01234";
		//1.分配一个指定大小的缓冲区
		ByteBuffer buf = ByteBuffer.allocate(1024);
		System.out.println("-------allocate()-------");
		System.out.println("position: "+buf.position());
		System.out.println("limit: "+buf.limit());
		System.out.println("capacity: "+buf.capacity());
		
		//2.利用put()存入数据到缓冲区
		buf.put(str.getBytes());
		System.out.println("------put()------");
		System.out.println("position: "+buf.position());
		System.out.println("limit: "+buf.limit());
		System.out.println("capacity: "+buf.capacity());
		
		//3.切换到读取数据模式
		buf.flip();
		System.out.println("-------flip()---------");
		System.out.println("position: "+buf.position());
		System.out.println("limit: "+buf.limit());
		System.out.println("capacity: "+buf.capacity());
		//4.读取数据
		byte[] datas = new byte[buf.limit()];
		buf.get(datas);
		System.out.println("-------get()---------");
		System.out.println(new String(datas));
		System.out.println("position: "+buf.position());
		System.out.println("limit: "+buf.limit());
		System.out.println("capacity: "+buf.capacity());
		//5.rewind():可以重复读数据
		buf.rewind();
		System.out.println("-------rewind()--------");
		System.out.println("position: "+buf.position());
		System.out.println("limit: "+buf.limit());
		System.out.println("capacity: "+buf.capacity());
		//6.clear():清空缓冲区,但是里面的数据还在，但是数据处于被遗忘状态
		buf.clear();
		System.out.println("--------clear()--------");
		System.out.println("position: "+buf.position());
		System.out.println("limit: "+buf.limit());
		System.out.println("capacity: "+buf.capacity());
	}
}

输出：
-------allocate()-------
position: 0
limit: 1024
capacity: 1024
------put()------
position: 5
limit: 1024
capacity: 1024
-------flip()---------
position: 0
limit: 5
capacity: 1024
-------get()---------
01234
position: 5
limit: 5
capacity: 1024
-------rewind()--------
position: 0
limit: 5
capacity: 1024
--------clear()--------
position: 0
limit: 1024
capacity: 1024

	@Test
	public void test2() {
		String str = "abcdef";
		ByteBuffer buf = ByteBuffer.allocate(1024);
		buf.put(str.getBytes());
		buf.flip();
		byte[] datas = new byte[1024];
		buf.get(datas,0,2);
		System.out.println(new String(datas,0,2));
		System.out.println(buf.position());
        //标记position位置
		buf.mark();
		buf.get(datas,2,2);
		System.out.println(new String(datas));
		System.out.println(buf.position());
        //判断缓冲区是否还有数据
		buf.reset();
		System.out.println(buf.position());
        //判断缓冲区是否还有剩余数据
		System.out.println("----------");
		if(buf.hasRemaining()) {
            //输出剩余数量
			System.out.println(buf.remaining());
		}
	}

输出：
ab
2
abcd
4
2
----------
4

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

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

@Test
	public void test3() {
		//分配直接缓冲区
		ByteBuffer buf = ByteBuffer.allocateDirect(1024);
		System.out.println(buf.isDirect());
	}

输出：
true

2、通道（Channel）

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

通道的主要实现类

• java.nio.channels.Channel接口：
  • FileChannel
  • SocketChannel
  • ServerSocketChannel
  • DatagramChannel

获取通道

• Java针对支持通道的类提供了getChannel()方法
  • 本地IO
    • FileInputStream/FileOutputStream
    • RandonAccessFile
  • 网络IO
    • Socket
    • ServerSocket
    • DatagramSocket
• 在JDK1.7中的NIO.2（新改动的NIO）针对各个通道提供了静态方法open()
• 在JDK1.7中的NIO.2的Files工具类的newByteChannel()

package com.hsw.nio;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

import org.junit.Test;

public class TestChannel {
    //利用非直接缓冲区完成复制
	@Test
	public void test1() throws Exception {
		//利用通道完成文件的复制
		FileInputStream fis = new FileInputStream("1.jpg");
		FileOutputStream fos = new FileOutputStream("2.jpg");
		
		//获得通道
		FileChannel inChannel = fis.getChannel();
		FileChannel outChannel = fos.getChannel();
		
		//分配缓冲区大小
        //利用非直接缓冲区完成复制
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		//将通道中的数据存入缓冲区中
		//读
		while(inChannel.read(buf)!=-1) {
			//切换成读数据模式
			buf.flip();
			//将缓冲区中的数据写入通道
			outChannel.write(buf);
			buf.clear();
		}
		inChannel.close();
		outChannel.close();
		fis.close();
		fos.close();
	}
   @Test
	public void test2() throws Exception {
        //快的多
		FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
		FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);
		
		//内存映射文件
		MappedByteBuffer inMapBuffer = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
		MappedByteBuffer outMapBuffer = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
		
		//直接对缓冲区进行数据读写操作
		byte[] dst = new byte[inMapBuffer.limit()];
		inMapBuffer.get(dst);
		outMapBuffer.put(dst);
		inChannel.close();
		outChannel.close();
	}
}

通道之间的数据传输

• transferFrom()
• transferTo()

@Test
	public void test3() throws Exception {
		//直接利用通道方法的传送
		FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
		FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);
	//	inChannel.transferTo(0, inChannel.size(), outChannel);
		outChannel.transferFrom(inChannel, 0, inChannel.size());
		inChannel.close();
		outChannel.close();
	}

分散（Scatter）与聚集（Gather）

• 分散读取（Scattering Reads）:将通道中的数据分散到多个缓冲区中
• 聚集写入（Gathering Writes）:将多个缓冲区中的数据聚集到一个通道中

@Test
	public void test4() throws Exception {
		RandomAccessFile raf = new RandomAccessFile("1.txt", "rw");
		//分配通道
		FileChannel channel = raf.getChannel();
		//分配缓冲区
		ByteBuffer buf1 = ByteBuffer.allocate(100);
		ByteBuffer buf2 = ByteBuffer.allocate(1024);
		ByteBuffer[] bufs = {buf1,buf2};
		//分散读取
		channel.read(bufs);
		
		for (ByteBuffer byteBuffer : bufs) {
			byteBuffer.flip();//设置成读模式
		}
		System.out.println(new String(buf1.array(),0,buf1.limit()));
		System.out.println("------------------------");
		System.out.println(new String(buf2.array(),0,buf2.limit()));
		//聚集写入
		RandomAccessFile raf2 = new RandomAccessFile("2.txt","rw");
		FileChannel fc = raf2.getChannel();
		fc.write(bufs);
	}

字符集：Charset

• 编码：字符串—>字节数组
• 解码：字节数组—>字符串

	@Test
	public void test5() {
        //获取所有字符集
		SortedMap<String,Charset> map = Charset.availableCharsets();
		Set<String> keySet = map.keySet();
		for (String string : keySet) {
			System.out.println(string+"---"+map.get(string));
		}
	}

	//字符集
	@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);
		
		System.out.println(bBuf.capacity());
		bBuf.position(bBuf.capacity());
//		for (int i = 0; i < 12; i++) {
//			bBuf.get();
//			System.out.println("position:"+bBuf.position());
//		}
		
		//解码
		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());
	}

输出：
6
牛皮啊
------------------------------------------------------
????

FileChannel 的常用方法

方 法	描 述
int read(ByteBuffer dst)	从Channel中读取数据到ByteBuffer
long read(ByteBuffer[] dsts)	将Channel中的数据“分散”到ByteBuffer[]
int write(ByteBuffer src)	将 ByteBuffer中的数据写入到Channel
long write(ByteBuffer[] srcs)	将ByteBuffer[]的数据“聚集”到Channel
long position()	返回此通道的文件位置
FileChannel position(long p)	设置此通道的文件位置
long size()	返回此通道的文件的当前大小
FileChannel truncate(long s)	将此通道的文件截取为给定大小
void force(boolean metaData)	强制将所有对此通道的文件更新写入到存储设备中

四、NIO的非阻塞式网络通信

阻塞与非阻塞

• 传统的IO流都是阻塞式的。也就是说，当一个线程调用read()或write()时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此在完成网络通信进行IO操作时，由于线程会阻塞，所以服务器必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要大量客户端时，性能急剧下降。
• javaNIO是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞IO的空闲时间用于在其他通道上执行IO操作，所以单独的线程可以管理多个输入和输出通道。因此NIO可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。

一、使用NIO完成网络通信的三个核心

• 通道：负责连接
  • java.nio.channels.Channel 接口
    • SelectableChannel
      • SocketChannel
      • ServerSocketChannel
      • DatagramChannel
    • Pipe.SinkChannel
    • Pipe.SourceChannel
• 缓冲区：负责数据的存取
• 选择器：是SelectableChannel的多路复用器。用于监控SelectableChannel的IO状况

阻塞式IO

package com.hsw.nio;

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;

import org.junit.Test;

/*
 * 一、使用 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();
		
	}
	
}

阻塞式服务端接收数据后反馈消息

package com.hsw.nio;

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;

import org.junit.Test;

public class TestBlockingBNIO2 {
	@Test
	public void client() throws IOException {
		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
		ByteBuffer buf = ByteBuffer.allocate(1024);
		FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
		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();
		}
		sChannel.close();
		inChannel.close();
	}
	@Test
	public void server() throws IOException {
		ServerSocketChannel ssChannel = ServerSocketChannel.open();
		ssChannel.bind(new InetSocketAddress(9999));
		FileChannel outChannel = FileChannel.open(Paths.get("3.jpg"),StandardOpenOption.WRITE,StandardOpenOption.CREATE);
		ByteBuffer buf = ByteBuffer.allocate(1024);
		SocketChannel sChannel = ssChannel.accept();
		while(sChannel.read(buf)!=-1) {
			buf.flip();
			outChannel.write(buf);
			buf.clear();
		}
		//给客户端发送反馈
		buf.put("服务端接收数据成功".getBytes());
		buf.flip();
		sChannel.write(buf);
		sChannel.close();
		ssChannel.close();
		outChannel.close();
	}
}

选择器

• 选择器（Selector） 是 SelectableChannle 对象的多路复用器，Selector 可以同时监控多个SelectableChannel 的 IO 状况，也就是说，利用 Selector可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心。

• SelectableChannle 的结构如下图：

  

选择器（Selector）

• 创建Selector：通过调用 Selector.open() 方法创建一个 Selector。

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

• 向选择器注册通道：SelectableChannel.register(Selector sel, int ops)

• 当调用 register(Selector sel, int ops) 将通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数 ops 指定。

• ops可以监听的事件类型（可使用 SelectionKey的四个常量表示）：

  • 读 : SelectionKey.OP_READ （1）
  • 写 : SelectionKey.OP_WRITE （4）
  • 连接 : SelectionKey.OP_CONNECT （8）
  • 接收 : SelectionKey.OP_ACCEPT （16）
  • 若注册时不止监听一个事件，则可以使用“位或”操作符连接。

• Selector相关方法如下：
  

• SelectionKey：表示 SelectableChannel 和 Selector 之间的注册关系。每次向选择器注册通道时就会选择一个事件(选择键)。选择键包含两个表示为整数值的操作集。操作集的每一位都表示该键的通道所支持的一类可选择操作。SelectionKey的相关方法如下：

非阻塞式IO

package com.hsw.nio;

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

import org.junit.Test;

/*
 * 一、使用 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();
			}
		}
	}
}

DatagramChannel

package com.hsw.nio;

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;

import org.junit.Test;

public class TestNonBlockingNIO2 {
	
	@Test
	public void send() throws IOException{
		DatagramChannel dc = DatagramChannel.open();
		
		dc.configureBlocking(false);
		
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		Scanner scan = new Scanner(System.in);
		
		while(scan.hasNext()){
			String str = scan.next();
			buf.put((new Date().toString() + ":\n" + str).getBytes());
			buf.flip();
			dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
			buf.clear();
		}
		
		dc.close();
	}
	
	@Test
	public void receive() throws IOException{
		DatagramChannel dc = DatagramChannel.open();
		
		dc.configureBlocking(false);
		
		dc.bind(new InetSocketAddress(9898));
		
		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 buf = ByteBuffer.allocate(1024);
					dc.receive(buf);
					buf.flip();
					System.out.println(new String(buf.array(), 0, buf.limit()));
					buf.clear();
				}
			}
			
			it.remove();
		}
	}

}

五、通道（Pipe）

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

package com.hsw.nio;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

import org.junit.Test;

public class TestPipe {

	@Test
	public void test1() throws IOException{
        //实际是多线程
		//1. 获取管道
		Pipe pipe = Pipe.open();
		
		//2. 将缓冲区中的数据写入管道
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		Pipe.SinkChannel sinkChannel = pipe.sink();
		buf.put("通过单向管道发送数据".getBytes());
		buf.flip();
		sinkChannel.write(buf);
		
		//3. 读取缓冲区中的数据
		Pipe.SourceChannel sourceChannel = pipe.source();
		buf.flip();
		int len = sourceChannel.read(buf);
		System.out.println(new String(buf.array(), 0, len));
		
		sourceChannel.close();
		sinkChannel.close();
	}
	
}