最近由于工作关系要做一些Java方面的开发,其中最重要的一块就是Java NIO(New I/O),尽管很早以前了解过一些,但并没有认真去看过它的实现原理,也没有机会在工作中使用,这次也好重新研究一下,顺便写点东西,就当是自己学习 Java NIO的笔记了。本文为NIO使用及原理分析的第一篇,将会介绍NIO中几个重要的概念。
在Java1.4之前的I/O系统中,提供的都是面向流的I/O系统,系统一次一个字节地处理数据,一个输入流产生一个字节的数据,一个输出流消费一个字节的数据,面向流的I/O速度非常慢,而在Java 1.4中推出了NIO,这是一个面向块的I/O系统,系统以块的方式处理处理,每一个操作在一步中产生或者消费一个数据库,按块处理要比按字节处理数据快的多。
在NIO中有几个核心对象需要掌握:缓冲区(Buffer)、通道(Channel)、选择器(Selector)。
缓冲区Buffer
缓冲区实际上是一个容器对象,更直接的说,其实就是一个数组,在NIO库中,所有数据都是用缓冲区处理的。在读取数据时,它是直接读到缓冲区中的; 在写入数据时,它也是写入到缓冲区中的;任何时候访问 NIO 中的数据,都是将它放到缓冲区中。而在面向流I/O系统中,所有数据都是直接写入或者直接将数据读取到Stream对象中。
在NIO中,所有的缓冲区类型都继承于抽象类Buffer,最常用的就是ByteBuffer,对于Java中的基本类型,基本都有一个具体Buffer类型与之相对应,它们之间的继承关系如下图所示:
下面是一个简单的使用IntBuffer的例子:
importjava.nio.IntBuffer;
publicclassTestIntBuffer{
publicstaticvoidmain(String[]args){
//分配新的int缓冲区,参数为缓冲区容量
//新缓冲区的当前位置将为零,其界限(限制位置)将为其容量。它将具有一个底层实现数组,其数组偏移量将为零。
IntBufferbuffer=IntBuffer.allocate(8);
for(inti=0;i intj=2*(i+1);
//将给定整数写入此缓冲区的当前位置,当前位置递增
buffer.put(j);
}
//重设此缓冲区,将限制设置为当前位置,然后将当前位置设置为0
buffer.flip();
//查看在当前位置和限制位置之间是否有元素
while(buffer.hasRemaining()){
//读取此缓冲区当前位置的整数,然后当前位置递增
intj=buffer.get();
System.out.print(j+"");
}
}
}
运行后可以看到:
在后面我们还会继续分析Buffer对象,以及它的几个重要的属性。
通道Channel
通道是一个对象,通过它可以读取和写入数据,当然了所有数据都通过Buffer对象来处理。我们永远不会将字节直接写入通道中,相反是将数据写入包含一个或者多个字节的缓冲区。同样不会直接从通道中读取字节,而是将数据从通道读入缓冲区,再从缓冲区获取这个字节。
在NIO中,提供了多种通道对象,而所有的通道对象都实现了Channel接口。它们之间的继承关系如下图所示:
使用NIO读取数据
在前面我们说过,任何时候读取数据,都不是直接从通道读取,而是从通道读取到缓冲区。所以使用NIO读取数据可以分为下面三个步骤:
1. 从FileInputStream获取Channel
2. 创建Buffer
3. 将数据从Channel读取到Buffer中
下面是一个简单的使用NIO从文件中读取数据的例子:
[java]view plaincopy
print?
importjava.io.*;
importjava.nio.*;
importjava.nio.channels.*;
publicclassProgram{
staticpublicvoidmain(Stringargs[])throwsException{
FileInputStreamfin=newFileInputStream("c:\\test.txt");
//获取通道
FileChannelfc=fin.getChannel();
//创建缓冲区
ByteBufferbuffer=ByteBuffer.allocate(1024);
//读取数据到缓冲区
fc.read(buffer);
buffer.flip();
while(buffer.remaining()>0){
byteb=buffer.get();
System.out.print(((char)b));
}
fin.close();
}
}
使用NIO写入数据
使用NIO写入数据与读取数据的过程类似,同样数据不是直接写入通道,而是写入缓冲区,可以分为下面三个步骤:
1. 从FileInputStream获取Channel
2. 创建Buffer
3. 将数据从Channel写入到Buffer中
下面是一个简单的使用NIO向文件中写入数据的例子:
[java]view plaincopy
print?
importjava.io.*;
importjava.nio.*;
importjava.nio.channels.*;
publicclassProgram{
staticprivatefinalbytemessage[]={83,111,109,101,32,
98,121,116,101,115,46};
staticpublicvoidmain(Stringargs[])throwsException{
FileOutputStreamfout=newFileOutputStream("c:\\test.txt");
FileChannelfc=fout.getChannel();
ByteBufferbuffer=ByteBuffer.allocate(1024);
for(inti=0;i buffer.put(message[i]);
}
buffer.flip();
fc.write(buffer);
fout.close();
}
}
本文介绍了Java NIO中三个核心概念中的两个,并且看了两个简单的示例,分别是使用NIO进行数据的读取和写入,Java NIO中最重要的一块Nonblocking I/O将在第三篇中进行分析,下篇将会介绍Buffer内部实现。
在第一篇中,我们介绍了NIO中的两个核心对象:缓冲区和通道,在谈到缓冲区时,我们说缓冲区对象本质上是一个数组,但它其实是一个特殊的数组,缓冲区对象内置了一些机制,能够跟踪和记录缓冲区的状态变化情况,如果我们使用get()方法从缓冲区获取数据或者使用put()方法把数据写入缓冲区,都会引起缓冲区状态的变化。本文为NIO使用及原理分析的第二篇,将会分析NIO中的Buffer对象。
在缓冲区中,最重要的属性有下面三个,它们一起合作完成对缓冲区内部状态的变化跟踪:
position:指定了下一个将要被写入或者读取的元素索引,它的值由get()/put()方法自动更新,在新创建一个Buffer对象时,position被初始化为0。
limit:指定还有多少数据需要取出(在从缓冲区写入通道时),或者还有多少空间可以放入数据(在从通道读入缓冲区时)。
capacity:指定了可以存储在缓冲区中的最大数据容量,实际上,它指定了底层数组的大小,或者至少是指定了准许我们使用的底层数组的容量。
以上四个属性值之间有一些相对大小的关系:0 <= position <= limit <= capacity。如果我们创建一个新的容量大小为10的ByteBuffer对象,在初始化的时候,position设置为0,limit和 capacity被设置为10,在以后使用ByteBuffer对象过程中,capacity的值不会再发生变化,而其它两个个将会随着使用而变化。四个属性值分别如图所示:
现在我们可以从通道中读取一些数据到缓冲区中,注意从通道读取数据,相当于往缓冲区中写入数据。如果读取4个自己的数据,则此时position的值为4,即下一个将要被写入的字节索引为4,而limit仍然是10,如下图所示:
下一步把读取的数据写入到输出通道中,相当于从缓冲区中读取数据,在此之前,必须调用flip()方法,该方法将会完成两件事情:
1. 把limit设置为当前的position值
2. 把position设置为0
由于position被设置为0,所以可以保证在下一步输出时读取到的是缓冲区中的第一个字节,而limit被设置为当前的position,可以保证读取的数据正好是之前写入到缓冲区中的数据,如下图所示:
现在调用get()方法从缓冲区中读取数据写入到输出通道,这会导致position的增加而limit保持不变,但position不会超过limit的值,所以在读取我们之前写入到缓冲区中的4个自己之后,position和limit的值都为4,如下图所示:
在从缓冲区中读取数据完毕后,limit的值仍然保持在我们调用flip()方法时的值,调用clear()方法能够把所有的状态变化设置为初始化时的值,如下图所示:
最后我们用一段代码来验证这个过程,如下所示:
[java]view plaincopy
print?
importjava.io.*;
importjava.nio.*;
importjava.nio.channels.*;
publicclassProgram{
publicstaticvoidmain(Stringargs[])throwsException{
FileInputStreamfin=newFileInputStream("d:\\test.txt");
FileChannelfc=fin.getChannel();
ByteBufferbuffer=ByteBuffer.allocate(10);
output("初始化",buffer);
fc.read(buffer);
output("调用read()",buffer);
buffer.flip();
output("调用flip()",buffer);
while(buffer.remaining()>0){
byteb=buffer.get();
//System.out.print(((char)b));
}
output("调用get()",buffer);
buffer.clear();
output("调用clear()",buffer);
fin.close();
}
publicstaticvoidoutput(Stringstep,Bufferbuffer){
System.out.println(step+":");
System.out.print("capacity:"+buffer.capacity()+",");
System.out.print("position:"+buffer.position()+",");
System.out.println("limit:"+buffer.limit());
System.out.println();
}
}
完成的输出结果为:
这与我们上面演示的过程一致。在后面的文章中,我们继续介绍NIO中关于缓冲区一些更高级的使用。
在上一篇文章中介绍了缓冲区内部对于状态变化的跟踪机制,而对于NIO中缓冲区来说,还有很多的内容值的学习,如缓冲区的分片与数据共享,只读缓冲区等。在本文中我们来看一下缓冲区一些更细节的内容。
缓冲区的分配
在前面的几个例子中,我们已经看过了,在创建一个缓冲区对象时,会调用静态方法allocate()来指定缓冲区的容量,其实调用 allocate()相当于创建了一个指定大小的数组,并把它包装为缓冲区对象。或者我们也可以直接将一个现有的数组,包装为缓冲区对象,如下示例代码所示:
[java]view plaincopy
print?
publicclassBufferWrap{
publicvoidmyMethod()
{
//分配指定大小的缓冲区
ByteBufferbuffer1=ByteBuffer.allocate(10);
//包装一个现有的数组
bytearray[]=newbyte[10];
ByteBufferbuffer2=ByteBuffer.wrap(array);
}
}
缓冲区分片
在NIO中,除了可以分配或者包装一个缓冲区对象外,还可以根据现有的缓冲区对象来创建一个子缓冲区,即在现有缓冲区上切出一片来作为一个新的缓冲区,但现有的缓冲区与创建的子缓冲区在底层数组层面上是数据共享的,也就是说,子缓冲区相当于是现有缓冲区的一个视图窗口。调用slice()方法可以创建一个子缓冲区,让我们通过例子来看一下:
[java]view plaincopy
print?
importjava.nio.*;
publicclassProgram{
staticpublicvoidmain(Stringargs[])throwsException{
ByteBufferbuffer=ByteBuffer.allocate(10);
//缓冲区中的数据0-9
for(inti=0;i buffer.put((byte)i);
}
//创建子缓冲区
buffer.position(3);
buffer.limit(7);
ByteBufferslice=buffer.slice();
//改变子缓冲区的内容
for(inti=0;i byteb=slice.get(i);
b*=10;
slice.put(i,b);
}
buffer.position(0);
buffer.limit(buffer.capacity());
while(buffer.remaining()>0){
System.out.println(buffer.get());
}
}
} 在该示例中,分配了一个容量大小为10的缓冲区,并在其中放入了数据0-9,而在该缓冲区基础之上又创建了一个子缓冲区,并改变子缓冲区中的内容,从最后输出的结果来看,只有子缓冲区“可见的”那部分数据发生了变化,并且说明子缓冲区与原缓冲区是数据共享的,输出结果如下所示:
只读缓冲区
只读缓冲区非常简单,可以读取它们,但是不能向它们写入数据。可以通过调用缓冲区的asReadOnlyBuffer()方法,将任何常规缓冲区转 换为只读缓冲区,这个方法返回一个与原缓冲区完全相同的缓冲区,并与原缓冲区共享数据,只不过它是只读的。如果原缓冲区的内容发生了变化,只读缓冲区的内容也随之发生变化:
[java]view plaincopy
print?
importjava.nio.*;
publicclassProgram{
staticpublicvoidmain(Stringargs[])throwsException{
ByteBufferbuffer=ByteBuffer.allocate(10);
//缓冲区中的数据0-9
for(inti=0;i buffer.put((byte)i);
}
//创建只读缓冲区
ByteBufferreadonly=buffer.asReadOnlyBuffer();
//改变原缓冲区的内容
for(inti=0;i byteb=buffer.get(i);
b*=10;
buffer.put(i,b);
}
readonly.position(0);
readonly.limit(buffer.capacity());
//只读缓冲区的内容也随之改变
while(readonly.remaining()>0){
System.out.println(readonly.get());
}
}
}
如果尝试修改只读缓冲区的内容,则会报ReadOnlyBufferException异常。只读缓冲区对于保护数据很有用。在将缓冲区传递给某个 对象的方法时,无法知道这个方法是否会修改缓冲区中的数据。创建一个只读的缓冲区可以保证该缓冲区不会被修改。只可以把常规缓冲区转换为只读缓冲区,而不能将只读的缓冲区转换为可写的缓冲区。
直接缓冲区
直接缓冲区是为加快I/O速度,使用一种特殊方式为其分配内存的缓冲区,JDK文档中的描述为:给定一个直接字节缓冲区,Java虚拟机将尽最大努 力直接对它执行本机I/O操作。也就是说,它会在每一次调用底层操作系统的本机I/O操作之前(或之后),尝试避免将缓冲区的内容拷贝到一个中间缓冲区中 或者从一个中间缓冲区中拷贝数据。要分配直接缓冲区,需要调用allocateDirect()方法,而不是allocate()方法,使用方式与普通缓冲区并无区别,如下面的拷贝文件示例:
[java]view plaincopy
print?
importjava.io.*;
importjava.nio.*;
importjava.nio.channels.*;
publicclassProgram{
staticpublicvoidmain(Stringargs[])throwsException{
Stringinfile="c:\\test.txt";
FileInputStreamfin=newFileInputStream(infile);
FileChannelfcin=fin.getChannel();
Stringoutfile=String.format("c:\\testcopy.txt");
FileOutputStreamfout=newFileOutputStream(outfile);
FileChannelfcout=fout.getChannel();
//使用allocateDirect,而不是allocate
ByteBufferbuffer=ByteBuffer.allocateDirect(1024);
while(true){
buffer.clear();
intr=fcin.read(buffer);
if(r==-1){
break;
}
buffer.flip();
fcout.write(buffer);
}
}
}
内存映射文件I/O
内存映射文件I/O是一种读和写文件数据的方法,它可以比常规的基于流或者基于通道的I/O快的多。内存映射文件I/O是通过使文件中的数据出现为 内存数组的内容来完成的,这其初听起来似乎不过就是将整个文件读到内存中,但是事实上并不是这样。一般来说,只有文件中实际读取或者写入的部分才会映射到内存中。如下面的示例代码:
[java]view plaincopy
print?
importjava.io.*;
importjava.nio.*;
importjava.nio.channels.*;
publicclassProgram{
staticprivatefinalintstart=0;
staticprivatefinalintsize=1024;
staticpublicvoidmain(Stringargs[])throwsException{
RandomAccessFileraf=newRandomAccessFile("c:\\test.txt","rw");
FileChannelfc=raf.getChannel();
MappedByteBuffermbb=fc.map(FileChannel.MapMode.READ_WRITE,
start,size);
mbb.put(0,(byte)97);
mbb.put(1023,(byte)122);
raf.close();
}
}
关于缓冲区的细节内容,我们已经用了两篇文章来介绍。在下一篇中将会介绍NIO中更有趣的部分Nonblocking I/O。
在上一篇文章中介绍了关于缓冲区的一些细节内容,现在终于可以进入NIO中最有意思的部分非阻塞I/O。通常在进行同步I/O操作时,如果读取数据,代码会阻塞直至有 可供读取的数据。同样,写入调用将会阻塞直至数据能够写入。传统的Server/Client模式会基于TPR(Thread per Request),服务器会为每个客户端请求建立一个线程,由该线程单独负责处理一个客户请求。这种模式带来的一个问题就是线程数量的剧增,大量的线程会增大服务器的开销。大多数的实现为了避免这个问题,都采用了线程池模型,并设置线程池线程的最大数量,这由带来了新的问题,如果线程池中有200个线程,而有200个用户都在进行大文件下载,会导致第201个用户的请求无法及时处理,即便第201个用户只想请求一个几KB大小的页面。传统的 Server/Client模式如下图所示:
NIO中非阻塞I/O采用了基于Reactor模式的工作方式,I/O调用不会被阻塞,相反是注册感兴趣的特定I/O事件,如可读数据到达,新的套接字连接等等,在发生特定事件时,系统再通知我们。NIO中实现非阻塞I/O的核心对象就是Selector,Selector就是注册各种I/O事件地 方,而且当那些事件发生时,就是这个对象告诉我们所发生的事件,如下图所示:
从图中可以看出,当有读或写等任何注册的事件发生时,可以从Selector中获得相应的SelectionKey,同时从 SelectionKey中可以找到发生的事件和该事件所发生的具体的SelectableChannel,以获得客户端发送过来的数据。关于 SelectableChannel的可以参考Java NIO使用及原理分析(一)
使用NIO中非阻塞I/O编写服务器处理程序,大体上可以分为下面三个步骤:
1. 向Selector对象注册感兴趣的事件
2. 从Selector中获取感兴趣的事件
3. 根据不同的事件进行相应的处理
接下来我们用一个简单的示例来说明整个过程。首先是向Selector对象注册感兴趣的事件:
[java]view plaincopy
print?
/*
*注册事件
**/
protectedSelectorgetSelector()throwsIOException{
//创建Selector对象
Selectorsel=Selector.open();
//创建可选择通道,并配置为非阻塞模式
ServerSocketChannelserver=ServerSocketChannel.open();
server.configureBlocking(false);
//绑定通道到指定端口
ServerSocketsocket=server.socket();
InetSocketAddressaddress=newInetSocketAddress(port);
socket.bind(address);
//向Selector中注册感兴趣的事件
server.register(sel,SelectionKey.OP_ACCEPT);
returnsel;
}
创建了ServerSocketChannel对象,并调用configureBlocking()方法,配置为非阻塞模式,接下来的三行代码把该通道绑定到指定端口,最后向Selector中注册事件,此处指定的是参数是OP_ACCEPT,即指定我们想要监听accept事件,也就是新的连接发 生时所产生的事件,对于ServerSocketChannel通道来说,我们唯一可以指定的参数就是OP_ACCEPT。
从Selector中获取感兴趣的事件,即开始监听,进入内部循环:
[java]view plaincopy
print?
/*
*开始监听
**/
publicvoidlisten(){
System.out.println("listenon"+port);
try{
while(true){
//该调用会阻塞,直到至少有一个事件发生
selector.select();
Setkeys=selector.selectedKeys();
Iteratoriter=keys.iterator();
while(iter.hasNext()){
SelectionKeykey=(SelectionKey)iter.next();
iter.remove();
process(key);
}
}
}catch(IOExceptione){
e.printStackTrace();
}
}
在非阻塞I/O中,内部循环模式基本都是遵循这种方式。首先调用select()方法,该方法会阻塞,直到至少有一个事件发生,然后再使用selectedKeys()方法获取发生事件的SelectionKey,再使用迭代器进行循环。
最后一步就是根据不同的事件,编写相应的处理代码:
[java]view plaincopy
print?
/*
*根据不同的事件做处理
**/
protectedvoidprocess(SelectionKeykey)throwsIOException{
//接收请求
if(key.isAcceptable()){
ServerSocketChannelserver=(ServerSocketChannel)key.channel();
SocketChannelchannel=server.accept();
channel.configureBlocking(false);
channel.register(selector,SelectionKey.OP_READ);
}
//读信息
elseif(key.isReadable()){
SocketChannelchannel=(SocketChannel)key.channel();
intcount=channel.read(buffer);
if(count>0){
buffer.flip();
CharBuffercharBuffer=decoder.decode(buffer);
name=charBuffer.toString();
SelectionKeysKey=channel.register(selector,SelectionKey.OP_WRITE);
sKey.attach(name);
}else{
channel.close();
}
buffer.clear();
}
//写事件
elseif(key.isWritable()){
SocketChannelchannel=(SocketChannel)key.channel();
Stringname=(String)key.attachment();
ByteBufferblock=encoder.encode(CharBuffer.wrap("Hello"+name));
if(block!=null)
{
channel.write(block);
}
else
{
channel.close();
}
}
}
此处分别判断是接受请求、读数据还是写事件,分别作不同的处理。
到这里关于Java NIO使用及原理分析的四篇文章就全部完成了。Java NIO提供了通道、缓冲区、选择器这样一组抽象概念,极大的简化了我们编写高性能并发型服务器程序,后面有机会我会继续谈谈使用Java NIO的一些想法。
来源: http://www.92to.com/bangong/2016/12-03/13846191.html