小白学习NIO
什么是NIO？
java中的NIO，当然也叫New IO,是从java1.4版本开始引入的一个新的IO API，可以代替标准的Java IO。使用NIO有什么好处呢
其实NIO和IO有着同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区，基于通道的的一种IO操作，是非阻塞是式的IO。IO是支持面向流的操作,是阻塞式的。显然NIO比IO有着更高的读写效率。
NIO三个重要组件
- 通道(Channel):表示打开到IO设备(例如：文件、 套接字)的连接。Channel 只能与 Buffer 进行交互，就是用来传输数据的。
- 缓冲区(Buffer):一个用来存储基本数据类型的容器，Java NIO 中的 Buffer 主要用于与 NIO 通道进行 交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。由 java.nio 包定义的，所有缓冲区 都是 Buffer 抽象类的子类。
- 选择器(Selector):是 SelectableChannle 对象的多路复用器，Selector 可 以同时监控多个 SelectableChannel 的 IO 状况，也就是说，利用 Selector 可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心。
通道(Channel)
Java 为 Channel 接口提供的最主要实现类如下：
•FileChannel：用于读取、写入、映射和操作文件的通道。
•DatagramChannel：通过 UDP 读写网络中的数据通道。
•SocketChannel：通过 TCP 读写网络中的数据。
•ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来
的连接都会创建一个 SocketChannel。获取通道的一种方式是对支持通道的对象调用
getChannel() 方法。支持通道的类如下：
FileInputStream —> getChannel()—>FileChannelFileOutputStream—> 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 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();
}
}
}
}