以前nio包可能会要求高级才会需要，但是现在这部分内容已经属于常见的基础技能了，因为对nio这部分并不熟悉，所以花了些时间把这部分也补上来，这样之后的技能树就可以继续点下去了~。如果文中存在问题的话请帮忙指出。
过去我们使用的字节字符流操作属于传统IO，缺点在于它属于阻塞IO，比如InputStream的read()方法会等到数据被读取完成后才会继续向下走。之前看源码的时候就看到，其中的方法大部分都是有使用synchronized关键字来做到同步。在java 1.4的时候推出了nio包来提高速度和性能，不过也不用担心传统IO的使用，因为都已经使用nio重新实现过了。
nio的速度的提高得益于所使用的结构更接近于操作系统执行IO的方式，其中有三个概念，即：通道Channel和缓冲器Buffer、选择器Selector。可以从名称上理解这些概念:
通道Channel：类似于两点之间的路线，是数据交互的通道。
缓冲器Buffer：类似于路线之间的汽车，是装载数据的工具。
选择器Selector：类似于收费站，注册登记之后可以进行相应操作。
Channel
所有的通道都需要实现接口Channel，如下图所示：
Channel.png
接口Channel定义了两个方法open()和close()方法，下面又存在几个子接口如：ReadableByteChannel、WritableByteChannel，这两个接口定义的方法就是相应的读写方法int read(ByteBuffer dst)和int write(ByteBuffer src)，这两个接口之下还有共同的子接口ByteChannel,其中并没有添加新方法。不止于此，相应的还有各自的字节口如：接口ScatteringByteChannel继承于ReadableByteChannel，并且添加了两个读取的新方法long read(ByteBuffer[] dsts, int offset, int length)和long read(ByteBuffer[] dsts)，可以看到读取使用的是数组ByteBuffer[]，相应的还有接口GatheringByteChannel继承于接口WritableByteChannel，添加了类似的long write(ByteBuffer[] srcs, int offset, int length)和long write(ByteBuffer[] srcs)方法，这两个接口分别表示的是读和写通道。
除了这条线以外，还可以看到旁边也有相应的接口InterruptibleChannel和一些类，这里主要看一下SelectableChannel类，可以看到这个类中提供了两个方法SelectionKey register(Selector sel, int ops, Object att)和SelectionKey register(Selector sel, int ops)，说明它的子类能注册Selector。在图的最底下有四个类，即DatagramChannel、SocketChannel、FileChannel和ServerSocketChannel，分别对应四种情况即文件读写、UDP读写网络数据、TCP的Client和Server读写网络数据。虽然是最核心的类，但是可以看到这四个类是抽象类，并不能直接实例化，我们需要方法构建出它的实例，而不能直接new关键字。如，类FileChannel的实例可以通过旧的io操作类获取，如下所示：
/**
**FileChannel类实例获取
**/
public static void main(String[] arg0) throws FileNotFoundException{
FileChannel fileChanelTest1 = new FileInputStream("/test/test.txt").getChannel();
FileChannel fileChanelTest2 = new FileOutputStream("/test/test.txt").getChannel();
FileChannel fileChanelTest3 = new RandomAccessFile("/test/test.txt","1").getChannel();
}
其他的三个类则通过静态的open()方法获取对应实例，如下所示：
/**
**DatagramChannel的open()方法
**/
public static DatagramChannel open() throws IOException {
return SelectorProvider.provider().openDatagramChannel();
}
/**
**ServerSocketChannel的open()方法
**/
public static ServerSocketChannel open() throws IOException {
return SelectorProvider.provider().openServerSocketChannel();
}
/**
**SocketChannel的open()方法
**/
public static SocketChannel open() throws IOException {
return SelectorProvider.provider().openSocketChannel();
}
可以看到，这三个通道类都是通过SelectorProvider类的静态方法provider()返回SelectorProvider，然后获取对应的通道。可以看看这个类SelectorProvider，下面是它提供的几个公有方法：
/**
**SelectorProvider的公有方法
**/
public abstract DatagramChannel openDatagramChannel()throws IOException;
public abstract ServerSocketChannel openServerSocketChannel()throws IOException;
public abstract SocketChannel openSocketChannel()throws IOException;
public abstract Pipe openPipe()throws IOException;
public abstract AbstractSelector openSelector()throws IOException;
虽然这里都是抽象方法，但是可以看到，其中除了三个通道获取方法，还有两个其他的如Pipe和AbstractSelector也是在这里获取的，这个在接下来会看到。需要注意的是这四个关键通道类只有类FileChannel没有实现接口SelectableChannel，不能注册相应的Selector，也是因为不需要使用它实现网络操作。
Buffer
在java.nio包下存在大量缓冲器类，其中以Buffer类为父类，子类主要分为几大类如：ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer、StringCharBuffer和特殊的MappedByteBuffer、DirectByteBuffer。下面分析缓冲器类：
普通Buffer类
在Buffer类的定义中，存在字段mark、position 、limit和capacity。其中的capacity表示在Buffer缓冲器的大小，即，能写多少个byte、char或Int等，从这里就可以看出，Buffer其实是个容器；position表示读写时的当前位置；limit表示限制，即，在写模式下表示的最大的限制是capacity的值，而在读模式下则是当前position的值；mark表示标记。不仅于此，Buffer类还定义了一些方法，如下：
/**
**filp()方法源码
**/
public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}
/**
**reset()方法源码
**/
public final Buffer reset() {
int m = mark;
if (m < 0)
throw new InvalidMarkException();
position = m;
return this;
}
/**
**clear()方法源码
**/
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}
在flip()方法中将缓冲器的position赋值给limit，mark置为-1，position置为0，即，将Buffer从写模式切换到读模式时用到，一般调用在写完数据到Buffer之后；reset()方法则将mark值赋值给字段position；clear()方法则将缓冲器的position，mark和limit都进行写模式的重置。这些方法的具体用法在之后会写到。
在Buffer类的子类中存在着相应的数组字段用来存储数据，如ByteBuffer类存在byte[] hb，CharBuffer类存在char[] hb。其中也添加了些静态方法，如allocate(int capacity)，在ByteBuffer类中源码如下：
/**
**allocate(int capacity)方法ByteBuffer类中源码
**/
public static ByteBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapByteBuffer(capacity, capacity);
}
可以看到，返回的是一个ByteBuffer子类HeapByteBuffer的实例，而ByteBuffer类是一个抽象类，可以通过这个方法创建实例。当然，也不是只有这种方法才能创建实例，这些子类还提供了对应数据类型的wrap()方法，如下ByteBuffer中的wrap()源码:
/**
**wrap(byte[] array,int offset, int length)方法ByteBuffer类中源码
**/
public static ByteBuffer wrap(byte[] array,
int offset, int length)
{
try {
return new HeapByteBuffer(array, offset, length);
} catch (IllegalArgumentException x) {
throw new IndexOutOfBoundsException();
}
}
/**
**wrap(byte[] array)方法ByteBuffer类中源码
**/
public static ByteBuffer wrap(byte[] array) {
return wrap(array, 0, array.length);
}
通过这两个方法也可以创建对应的Buffer缓冲器。在这些方法中，返回的都是HeapByteBuffer类型实例，这个类是ByteBuffer的子类，操作的是堆内存，因为使用前需要将文件写入堆中，属于间接模式。说了这个缓冲器之后，可以看看直接模式下的缓存器类MappedByteBuffer和DirectByteBuffer。
MappedByteBuffer类
这个类是Java.nio引入的文件内存映射方案，读写性能特别高。既然是文件内存映射，操作的自然也是文件，在nio中也就是FileChannel通道来处理，可以在FileChannel看到如下代码：
/**
**map()方法示例
**/
public abstract MappedByteBuffer map(MapMode mode,long position, long size)throws IOException;
在这个方法中，需要传入参数：模式mode、位置position和大小size，通过这几个属性来映射文件，模式分为三种，即READ_ONLY、READ_WRITE和PRIVATE，其中PRIVATE指的是私有、对映射部分缓冲的更改不会传播到原始文件上，更改也不会对其他程序可见。在FileChannel的实现类FileChannelImpl中有这个方法的实现，有兴趣的可以自行查看。
在类MappedByteBuffer源代码还可以看到几个公有方法如下：
/**
**isLoaded方法代码示例
**/
public final boolean isLoaded() {
checkMapped();
if ((address == 0) || (capacity() == 0))
return true;
return isLoaded0(((DirectByteBuffer)this).address(), capacity());
}
/**
**load方法代码示例
**/
public final MappedByteBuffer load() {
checkMapped();
if ((address == 0) || (capacity() == 0))
return this;
load0(((DirectByteBuffer)this).address(), capacity(), Bits.pageSize());
return this;
}
/**
**force方法代码示例
**/
public final MappedByteBuffer force() {
checkMapped();
if ((address == 0) || (capacity() == 0))
return this;
force0(((DirectByteBuffer)this).address(), capacity());
return this;
}
//调用的原生方法
private native boolean isLoaded0(long address, long length);
private native int load0(long address, long length, int pageSize);
private native void force0(long address, long length);
这几个方法的作用是对映射区域的操作，其中方法load()将缓冲区的内容载入内存，并返回该缓冲区的引用；方法isLoaded()判断缓冲区的内容是否在物理内存中，若是则返回true，否则返回fasle；若是在READ_WRITE模式下，方法force()将对缓冲区映射的修改强行写入文件。
Selector
Java的nio包引入了选择器概念用来规避阻塞式线程的忙等操作，在上面写过，Selector的实例也是通过SelectorProvider类来获取，如下：
/**
**Selector的open()方法
**/
public static Selector open() throws IOException {
return SelectorProvider.provider().openSelector();
}
这里可以跟进，看一下SelectorProvider的provider方法代码，如下：
/**
**provider方法源码
**/
public static SelectorProvider provider() {
synchronized (lock) {
if (provider != null)
return provider;
return (SelectorProvider)AccessController
.doPrivileged(new PrivilegedAction() {
public Object run() {
if (loadProviderFromProperty())
return provider;
if (loadProviderAsService())
return provider;
provider = sun.nio.ch.DefaultSelectorProvider.create();
return provider;
}
});
}
}
在这里会创建provider实例，然后通过调用相应的方法返回对应的通道或Pipe、Selector。其实这类有一个特别的就是通过反射创建了它自己，所以抽象类是可以实例化的，只是不能通过new关键字实例化。其中有一些源码我也不是很懂，欢迎来一起讨论。
要了解Selector，不得不说的是类SelectableChannel和类SelectionKey，其中SelectableChannel提供了register()方法，用来给通道注册相应的选择器监听，而在类SelectionKey中定义了四个常量：OP_READ、OP_WRITE、OP_CONNECT和OP_ACCEPT，来表示读就绪、写就绪、连接就绪和接受就绪,我们可以使用相应的is方法判断是否就绪，如boolean isReadable()。不仅于此，这个类还有几个方法如下：
public abstract SelectableChannel channel(); //Channel集合
public abstract Selector selector(); //selector 集合
public abstract int interestOps(); //interest集合
public abstract SelectionKey interestOps(int ops); //interest集合
public abstract int readyOps(); //ready集合
//附加对象
public final Object attach(Object ob) {
Object a = attachment;
attachment = ob;
return a;
}
通过这些方法返回相应的事件集合或附加对象，我们可以通过这些事件进行相应的操作，具体的会在之后说到。
Pipe
在传统的IO中，有PipedInputStream/PipedOutputStream或PipedReader/PipedWriter之类的，在NIO中也有对应的Pipe管道来处理两个线程之间的通信。在这个类中，存在两个个静态内部类SourceChannel和SinkChannel，通过这两个通道来达到信息交互的目的。
在最后说明一下，如果在java.nio包下没有看到实现类，可以去sun.nio.ch包下查看相应实现类，毕竟很多的类在java.nio下只有抽象类，但是继承实现的是在sun.nio.ch包下。最后，文中有的不足之处欢迎指出。
参考：
java.nio包
sun.nio.ch包
网友评论