小白学习NIO

什么是NIO？

java中的NIO，当然也叫New IO,是从java1.4版本开始引入的一个新的IO API，可以代替标准的Java IO。使用NIO有什么好处呢

其实NIO和IO有着同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区，基于通道的的一种IO操作，是非阻塞是式的IO。IO是支持面向流的操作,是阻塞式的。显然NIO比IO有着更高的读写效率。

NIO三个重要组件

1. 通道(Channel):表示打开到IO设备(例如：文件、 套接字)的连接。Channel 只能与 Buffer 进行交互，就是用来传输数据的。
2. 缓冲区(Buffer):一个用来存储基本数据类型的容器，Java NIO 中的 Buffer 主要用于与 NIO 通道进行 交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。由 java.nio 包定义的，所有缓冲区 都是 Buffer 抽象类的子类。
3. 选择器(Selector):是 SelectableChannle 对象的多路复用器，Selector 可 以同时监控多个 SelectableChannel 的 IO 状况，也就是说，利用 Selector 可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心。

通道(Channel)

Java 为 Channel 接口提供的最主要实现类如下：
•FileChannel：用于读取、写入、映射和操作文件的通道。
•DatagramChannel：通过 UDP 读写网络中的数据通道。
•SocketChannel：通过 TCP 读写网络中的数据。
•ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来
的连接都会创建一个 SocketChannel。

获取通道的一种方式是对支持通道的对象调用
getChannel() 方法。支持通道的类如下：
FileInputStream   —>   getChannel()—>FileChannel

FileOutputStream—>   getChannel()—>FileChannel

RandomAccessFile—>   getChannel()—>FileChannel

Socket—>   getChannel()—>SocketChannel 
ServerSocket—>   getChannel()—>ServerSocketChannel 
DatagramSocket—>   getChannel()—>DatagramChannel 

注意一下方法，只有jdk1.7以上支持
获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。

或者通过通道的静态方法 open() 打开并返回指定通道。例如：FileChannel.open();

缓冲区(Buffer)

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

 ByteBuffer

 CharBuffer

 ShortBuffer

 IntBuffer

 LongBuffer

 FloatBuffer

 DoubleBuffer

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

 Buffer 中的重要概念：

 容量 (capacity) ：表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创 建后不能更改。

 限制 (limit)：第一个不应该读取或写入的数据的索引，即位于 limit 后的数据 不可读写。缓冲区的限制不能为负，并且不能大于其容量。

 位置 (position)：下一个要读取或写入的数据的索引。缓冲区的位置不能为 负，并且不能大于其限制

 标记 (mark)与重置 (reset)：标记是一个索引，通过 Buffer 中的 mark() 方法 指定 Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这 个 position.

 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)

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

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

字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在 此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后）， 虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。
直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消 分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对 应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的 本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好 处时分配它们。

直接字节缓冲区还可以通过FileChannel 的 map() 方法 将文件区域直接映射到内存中来创建。该方法返回 MappedByteBuffer 。Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区 中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在 访问期间或稍后的某个时间导致抛出不确定的异常。

字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在 性能关键型代码中执行显式缓冲区管理。

下面通过下面两个图，观察直接缓冲区与非直接缓冲区的区别

 

从中我们不难发现，直接缓冲区是直接系统内存中直接建立了一个内存映射文件，用户直接操作内存映射文件中的数据，然后，由操作系统直接将内存中的数据直接写到物理磁盘上；而非直接缓冲区，先将数据读取到内核空间，然后copy到JVM内存中，显然这个过程的效率对肯定不如直接缓冲区的效率高。

尽然通道和缓冲区我们都了解了，下面通过通道和缓冲区来实现文件复制

//利用通道完成文件的复制
	@Test
	public void test1(){
		FileInputStream fis=null;
		FileOutputStream fos=null;
		//获取通道
		FileChannel inChannel=null;
		FileChannel outChannel=null;
		try {
			fis = new FileInputStream("test1");
			fos = new FileOutputStream("test2");
			//通过IO流获取通道
			inChannel = fis.getChannel();
			outChannel = fos.getChannel();
			
			//分配指定大小的缓冲区
			ByteBuffer buffer=ByteBuffer.allocate(1024);
			
			//将通道中的数据存入缓冲区中
			while(inChannel.read(buffer)!=-1){
				buffer.flip();//切换读取数据缓冲区
				
				//将缓冲区中的数据写入通道
				outChannel.write(buffer);
				buffer.clear();//清空缓冲区
				
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		finally{
			if(outChannel!=null){
				try {
					outChannel.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(inChannel!=null){
				try {
					inChannel.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(fis!=null){
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(fos!=null){
				try {
					fos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}

再来一个例子，使用直接缓冲区完成文件复制，当然这种方式效率非常高，相比非直接缓冲区来说。

//使用直接缓冲区完成文件复制
	@Test
	public void test2(){
		FileChannel inChannel=null;
		FileChannel outChannel=null;
		MappedByteBuffer inMappedBuffer=null;
		MappedByteBuffer outMappedBuffer=null;
		try {
			//获取通道
			inChannel=FileChannel.open(Paths.get("test2"),StandardOpenOption.READ);//用来读取数据到该通道
			outChannel=FileChannel.open(Paths.get("test3"),StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE_NEW);
			//StandardOpenOption.CREATE_NEW:表示如果文件存在，则出现异常；如果文件不存在，则创建文件
			//StandardOpenOption.CREATE:表示如果文件存在，则覆盖；如果文件不存在，则创建文件
			
			inMappedBuffer = inChannel.map(MapMode.READ_ONLY, 0,inChannel.size());//创建映射缓冲区，
			outMappedBuffer = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());//创建映射缓冲区
		
		byte[] b=new byte[inMappedBuffer.limit()];//创建缓冲数组
		inMappedBuffer.get(b);//将缓冲区的数据读取到数组中
		outMappedBuffer.put(b);//将数组中的数据写入到输出缓冲区中
		}
		catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		finally{
			if(outChannel!=null){
				try {
					outChannel.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(inChannel!=null){
				try {
					inChannel.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}

	}

NIO里面还有两个方法，就是基于transferFrom()和transferTo()方法来完成基于通道之间的传输数据，代码如下：

   @Test
			public void test8() throws IOException{
				//获取通道
			 FileChannel inChannel = FileChannel.open(Paths.get("test1"),StandardOpenOption.READ);
		     FileChannel outChannel = FileChannel.open(Paths.get("test2"),StandardOpenOption.WRITE);
		     
		     //定义传输位置
		     long position=0;
		     //最多传输的字节数
		     long size=inChannel.size();
		     //将数据从inChannel传输到outChanel
		     inChannel.transferTo(position, size, outChannel);
		     
		     //outChannel.transferFrom(inChannel, position, size); 这是另一种传输方式
		     
		     inChannel.close();
		     outChannel.close();
		     
		     
			}

分散(Scatter)和聚集(Gather)

分散读取是指将Channel中读取的数据“分散”到多个Buffer中，注意是按照缓冲区的顺序，从Channel中读取的数据依次填满Buffer.如图

聚集写入是指将多个缓冲区的数据“聚集”到Channel,注意：按照缓冲区的顺序，写入position和limit之间的数据到Channel.

通过代码了解一下分散与聚集

//分散写入与聚集读取
			@Test
			public void test4(){
				try {
					RandomAccessFile ran=new RandomAccessFile("test4", "rw");
					FileChannel channel=ran.getChannel();//获取通道
					
                    //创建多个缓冲区
					ByteBuffer buf1=ByteBuffer.allocate(500);
					ByteBuffer buf2=ByteBuffer.allocate(1000);
					
					ByteBuffer[] buf={buf1,buf2};
                    //将通道中的数据分散到缓冲区中
					channel.read(buf);
					
					for (ByteBuffer byteBuffer : buf) {
						byteBuffer.flip();//将缓冲区切换为读模式
					}
					System.out.println(new String(buf[0].array(), 0, buf1.limit()));
					System.out.println("---------------------------------");
					System.out.println(new String(buf[1].array(),0,buf2.limit()));
				} catch (FileNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

 

阻塞与非阻塞

传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write() 时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不 能执行其他任务。因此，在完成网络通信进行 IO 操作时，由于线程会 阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理， 当服务器端需要处理大量客户端时，性能急剧下降。

java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数 据可用时，该线程可以进行其他任务。线程通常将非阻塞 IO 的空闲时 间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入 和输出通道。因此，NIO 可以让服务器端使用一个或有限几个线程来同 时处理连接到服务器端的所有客户端。

选择器（Selector)

选择器是NIO的核心，它是channel的管理者，Selector 可以同时监控多个 SelectableChannel 的 IO 状况，也就是说，利用 Selector 可使一个单独的线程管理多个 Channel，通过select()执行阻塞方法，监听是否有channel准备好，一旦有数据可读，此方法的返回值是SelectionKey的数量，所以服务端通常会死循环执行select()方法，直到有channl准备就绪，然后开始工作
每个channel都会和Selector绑定一个事件，然后生成一个SelectionKey的对象。

需要注意的是：
channel和Selector绑定时，channel必须是非阻塞模式，而FileChannel不能切换到非阻塞模式，因为它不是套接字通道，所以FileChannel不能和Selector绑定事件

在NIO中一共有四种事件，用来监听通道事件
1.SelectionKey.OP_CONNECT：连接事件
2.SelectionKey.OP_ACCEPT：接收事件
3.SelectionKey.OP_READ：读事件
4.SelectionKey.OP_WRITE：写事件

 将该通道注册到选择器上
   sChannel.register(selector, SelectionKey.OP_READ);

下面通过Socket传输，来模拟Selector

@Test//客户端向服务器端发送信息
			public void client() throws IOException{
				//获取一个SocketChannel的通道
				SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8989));
				//将通道设置成非阻塞模式
				sChannel.configureBlocking(false);
				//分配缓冲区
				ByteBuffer buf=ByteBuffer.allocate(1024);
				Scanner sc=new Scanner(System.in);
				while(sc.hasNext()){
					String string=sc.next();
					buf.put((new Date().toString()+"\n"+string).getBytes());//向缓冲区添加内容
					buf.flip();//设置读模式
					sChannel.write(buf);//将缓冲区的数据写到通道中
					buf.clear();//清空缓冲区
				}
				sChannel.close();
				
			}
			@Test//服务器端接收客户端的信息
			public void server() throws IOException{
				ServerSocketChannel ssChannel = ServerSocketChannel.open();
				//切换成非阻塞模式
				ssChannel.configureBlocking(false);
				//绑定连接
				ssChannel.bind(new InetSocketAddress(8989));
				//获取选择器
				Selector selector = Selector.open();
				//将通道注册到选择器上，并且指定"监听接收事件"
				ssChannel.register(selector, SelectionKey.OP_ACCEPT);
				//轮询式的获取选择器上已经"准备就绪"的事件
				while(selector.select()>0){
					//selector.select()只要有准备好的通道，select()的值大于0
					
					//获取当前选择器中的所有注册的“选择键(已经就绪的监听事件)”
					Iterator<SelectionKey> it=selector.selectedKeys().iterator();
					
					while(it.hasNext()){
						//获取当前“就绪”的事件
						SelectionKey sk=it.next();
						
						//如果为“接收就绪”
						if(sk.isAcceptable()){
							//获取客户端连接
							SocketChannel sChannel = ssChannel.accept();
							//将通道设置为非阻塞模式
							sChannel.configureBlocking(false);
							
							//将通道注册到选择器上
							sChannel.register(selector, SelectionKey.OP_READ);
							
						}else if(sk.isReadable()){
							//获取当前选择器上“读就绪”状态的通道
							SocketChannel sChannel=(SocketChannel)sk.channel();
							//读取数据
							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();
							}
							//当然这里还有其他情况
							
							//取消选择键
							it.remove();
						}
						
						
					}
				
				
				}
				
			}