java温故笔记(五)java的io bio nio aio

2018-02-11 14:09:13来源:oschina作者:wangchen1999人点击

分享

本文会从传统的IO到BIO到NIO再到AIO自浅至深介绍,并附上完整的代码讲解。


下面代码中会使用这样一个例子:客户端发送一段算式的字符串到服务器,服务器计算后返回结果到客户端。


代码的所有说明,都直接作为注释,嵌入到代码中,看代码时就能更容易理解,代码中会用到一个计算结果的工具类,见文章代码部分。


相关的基础知识文章推荐:


Linux 网络 I/O 模型简介(图文)


Java 并发(多线程)


1、IO编程
IO基础知识回顾

java的核心库java.io提供了全面的IO接口。包括:文件读写、标准设备输出等。Java中IO是以流为基础进行输入输出的,所有数据被串行化写入输出流,或者从输入流读入。


java.nio(java non-blocking IO),nio 是non-blocking的简称,是jdk1.4 及以上版本里提供的新api(New IO) ,为所有的原始类型(boolean类型除外)提供缓存支持。


Sun 官方标榜的特性如下: 为所有的原始类型提供(Buffer)缓存支持。字符集编码解码解决方案。


Channel :一个新的原始I/O 抽象。 支持锁和内存映射文件的文件访问接口。 提供多路(non-bloking) 非阻塞式的高伸缩性网络I/O 。


IO流类图结构


这里写图片描述


基本输入字节流:




功能


如何构造,怎样使用




ByteArrayInputStream


将内存中的Byte数组适配为一个InputStream。


从内存中的Byte数组创建该对象(2种方法)




一般作为数据源,会使用其它装饰流提供额外的功能,一般都建议加个缓冲功能。




StringBufferInputStream


将内存中的字符串适配为一个InputStream。


从一个String对象创建该对象。底层的实现使用StringBuffer。该类被Deprecated。主要原因是StringBuffer不应该属于字节流,所以推荐使用StringReader。




一般作为数据源,同样会使用其它装饰器提供额外的功能。




FileInputStream


最基本的文件输入流。主要用于从文件中读取信息。


通过一个代表文件路径的 String、File对象或者 FileDescriptor对象创建。




一般作为数据源,同样会使用其它装饰器提供额外的功能。




PipedInputStream


读取从对应PipedOutputStream写入的数据。在流中实现了管道的概念。


利用对应的PipedOutputStream创建。




在多线程程序中作为数据源,同样会使用其它装饰器提供额外的功能。




SequenceInputStream


将2个或者多个InputStream 对象转变为一个InputStream.


使用两个InputStream 或者内部对象为InputStream 的Enumeration对象创建该对象。




一般作为数据源,同样会使用其它装饰器提供额外的功能。




FilterInputStream


给其它被装饰对象提供额外功能的抽象类


主要子类见下表



装饰、输入字节流:




功能


如何构造,怎样使用




DataInputStream


一般和DataOutputStream配对使用,完成基本数据类型的读写。


利用一个InputStream构造。




提供了大量的读取基本数据类新的读取方法。




BufferedInputStream


使用该对象阻止每次读取一个字节都会频繁操作IO。将字节读取一个缓存区,从缓存区读取。


利用一个InputStream、或者带上一个自定义的缓存区的大小构造。




使用InputStream的方法读取,只是背后多一个缓存的功能。设计模式中透明装饰器的应用。




LineNumberInputStream


跟踪输入流中的行号。

可以调用getLineNumber()和 setLineNumber(int)方法得到和设置行号。


利用一个InputStream构造。




紧紧增加一个行号。可以象使用其它InputStream一样使用。




PushbackInputStream


可以在读取最后一个byte 后将其放回到缓存中。


利用一个InputStream构造。




一般仅仅会在设计compiler的scanner 时会用到这个类。在我们的java语言的编译器中使用它。很多程序员可能一辈子都不需要。




基本输出字节流:




功能


如何构造,怎样使用




ByteArrayOutputStream


在内存中创建一个buffer。所有写入此流中的数据都被放入到此buffer中。


无参或者使用一个可选的初始化buffer的大小的参数构造。




一般将其和FilterOutputStream套接得到额外的功能。建议首先和BufferedOutputStream套接实现缓冲功能。通过toByteArray方法可以得到流中的数据。(不通明装饰器的用法)




FileOutputStream


将信息写入文件中。


使用代表文件路径的String、File对象或者 FileDescriptor对象创建。还可以加一个代表写入的方式是否为append的标记。




一般将其和FilterOutputStream套接得到额外的功能。




PipedOutputStream


任何写入此对象的信息都被放入对应PipedInputStream 对象的缓存中,从而完成线程的通信,实现了“管道”的概念。具体在后面详细讲解。


利用PipedInputStream构造




在多线程程序中数据的目的地的。一般将其和FilterOutputStream套接得到额外的功能。




FilterOutputStream


实现装饰器功能的抽象类。为其它OutputStream对象增加额外的功能。


见下表



装饰输出字节流:




功能


如何构造,怎样使用




DataOutputStream


通常和DataInputStream配合使用,使用它可以写入基本数据类新。


使用OutputStream构造




包含大量的写入基本数据类型的方法。




PrintStream


产生具有格式的输出信息。(一般地在java程序中DataOutputStream用于数据的存储,即J2EE中持久层完成的功能,PrintStream完成显示的功能,类似于J2EE中表现层的功能)


使用OutputStream和一个可选的表示缓存是否在每次换行时是否flush的标记构造。还提供很多和文件相关的构造方法。




一般是一个终极(“final”)的包装器,很多时候我们都使用它!




BufferedOutputStream


使用它可以避免频繁地向IO写入数据,数据一般都写入一个缓存区,在调用flush方法后会清空缓存、一次完成数据的写入。


从一个OutputStream或者和一个代表缓存区大小的可选参数构造。




提供和其它OutputStream一致的接口,只是内部提供一个缓存的功能。



IO流简单例子


实例一:


FileInputStream fis=null;
FileOutputStream fos=null;
try {
fis = new FileInputStream(new File("D://a.txt"));
fos = new FileOutputStream(new File("D://y.txt"));
int ch;
while((ch=fis.read()) != -1){
System.out.println((char)ch);
fos.write(ch);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(null != fos){
fos.close();
}
if(null != fis){
fis.close();
}
}

这里写图片描述


实例二:字节流转换成字符流


public static void main(String[] args) throws Exception{
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream("D://a.txt")));
bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D://y.txt")));
String s;
StringBuilder sb = new StringBuilder();
while((s=br.readLine())!=null){
System.out.println(s);
bw.write(s);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(null != bw){
bw.close();
}
if(null != br){
br.close();
}
}
}

例三:用转换流从控制台上读入数据


public static void main(String[] args) throws Exception{
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(System.in));
String s=br.readLine();
System.out.println(s);
} catch (IOException e) {
e.printStackTrace();
}finally {
if(null != br){
br.close();
}
}
} 2、BIO编程
2.1、传统的BIO编程

网络编程的基本模型是C/S模型,即两个进程间的通信。


服务端提供IP和监听端口,客户端通过连接操作想服务端监听的地址发起连接请求,通过三次握手连接,如果连接成功建立,双方就可以通过套接字进行通信。


传统的同步阻塞模型开发中,ServerSocket负责绑定IP地址,启动监听端口;Socket负责发起连接操作。连接成功后,双方通过输入和输出流进行同步阻塞式通信。


简单的描述一下BIO的服务端通信模型:采用BIO通信模型的服务端,通常由一个独立的Acceptor线程负责监听客户端的连接,它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理没处理完成后,通过输出流返回应答给客户端,线程销毁。即典型的一请求一应答通宵模型。


传统BIO通信模型图:


01


该模型最大的问题就是缺乏弹性伸缩能力,当客户端并发访问量增加后,服务端的线程个数和客户端并发访问数呈1:1的正比关系,Java中的线程也是比较宝贵的系统资源,线程数量快速膨胀后,系统的性能将急剧下降,随着访问量的继续增大,系统最终就死-掉-了。


同步阻塞式I/O创建的Server源码:


packagecom.anxpp.io.calculator.bio;
importjava.io.IOException;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
*BIO服务端源码
*@authoryangtao__anxpp.com
*@version1.0
*/
publicfinalclassServerNormal{
//默认的端口号
privatestaticintDEFAULT_PORT=12345;
//单例的ServerSocket
privatestaticServerSocketserver;
//根据传入参数设置监听端口,如果没有参数调用以下方法并使用默认值
publicstaticvoidstart()throwsIOException{
//使用默认值
start(DEFAULT_PORT);
}
//这个方法不会被大量并发访问,不太需要考虑效率,直接进行方法同步就行了
publicsynchronizedstaticvoidstart(intport)throwsIOException{
if(server!=null)return;
try{
//通过构造函数创建ServerSocket
//如果端口合法且空闲,服务端就监听成功
server=newServerSocket(port);
System.out.println("服务器已启动,端口号:"+port);
//通过无线循环监听客户端连接
//如果没有客户端接入,将阻塞在accept操作上。
while(true){
Socketsocket=server.accept();
//当有新的客户端接入时,会执行下面的代码
//然后创建一个新的线程处理这条Socket链路
newThread(newServerHandler(socket)).start();
}
}finally{
//一些必要的清理工作
if(server!=null){
System.out.println("服务器已关闭。");
server.close();
server=null;
}
}
}
}

客户端消息处理线程ServerHandler源码:


packagecom.anxpp.io.calculator.bio;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
importjava.net.Socket;
importcom.anxpp.io.utils.Calculator;
/**
*客户端线程
*@authoryangtao__anxpp.com
*用于处理一个客户端的Socket链路
*/
publicclassServerHandlerimplementsRunnable{
privateSocketsocket;
publicServerHandler(Socketsocket){
this.socket=socket;
}
@Override
publicvoidrun(){
BufferedReaderin=null;
PrintWriterout=null;
try{
in=newBufferedReader(newInputStreamReader(socket.getInputStream()));
out=newPrintWriter(socket.getOutputStream(),true);
Stringexpression;
Stringresult;
while(true){
//通过BufferedReader读取一行
//如果已经读到输入流尾部,返回null,退出循环
//如果得到非空值,就尝试计算结果并返回
if((expression=in.readLine())==null)break;
System.out.println("服务器收到消息:"+expression);
try{
result=Calculator.cal(expression).toString();
}catch(Exceptione){
result="计算错误:"+e.getMessage();
}
out.println(result);
}
}catch(Exceptione){
e.printStackTrace();
}finally{
//一些必要的清理工作
if(in!=null){
try{
in.close();
}catch(IOExceptione){
e.printStackTrace();
}
in=null;
}
if(out!=null){
out.close();
out=null;
}
if(socket!=null){
try{
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
socket=null;
}
}
}
}

同步阻塞式I/O创建的Client源码:


packagecom.anxpp.io.calculator.bio;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
importjava.net.Socket;
/**
*阻塞式I/O创建的客户端
*@authoryangtao__anxpp.com
*@version1.0
*/
publicclassClient{
//默认的端口号
privatestaticintDEFAULT_SERVER_PORT=12345;
privatestaticStringDEFAULT_SERVER_IP="127.0.0.1";
publicstaticvoidsend(Stringexpression){
send(DEFAULT_SERVER_PORT,expression);
}
publicstaticvoidsend(intport,Stringexpression){
System.out.println("算术表达式为:"+expression);
Socketsocket=null;
BufferedReaderin=null;
PrintWriterout=null;
try{
socket=newSocket(DEFAULT_SERVER_IP,port);
in=newBufferedReader(newInputStreamReader(socket.getInputStream()));
out=newPrintWriter(socket.getOutputStream(),true);
out.println(expression);
System.out.println("___结果为:"+in.readLine());
}catch(Exceptione){
e.printStackTrace();
}finally{
//一下必要的清理工作
if(in!=null){
try{
in.close();
}catch(IOExceptione){
e.printStackTrace();
}
in=null;
}
if(out!=null){
out.close();
out=null;
}
if(socket!=null){
try{
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
socket=null;
}
}
}
}

测试代码,为了方便在控制台看输出结果,放到同一个程序(jvm)中运行:


packagecom.anxpp.io.calculator.bio;
importjava.io.IOException;
importjava.util.Random;
/**
*测试方法
*@authoryangtao__anxpp.com
*@version1.0
*/
publicclassTest{
//测试主方法
publicstaticvoidmain(String[]args)throwsInterruptedException{
//运行服务器
newThread(newRunnable(){
@Override
publicvoidrun(){
try{
ServerBetter.start();
}catch(IOExceptione){
e.printStackTrace();
}
}
}).start();
//避免客户端先于服务器启动前执行代码
Thread.sleep(100);
//运行客户端
charoperators[]={'+','-','*','/'};
Randomrandom=newRandom(System.currentTimeMillis());
newThread(newRunnable(){
@SuppressWarnings("static-access")
@Override
publicvoidrun(){
while(true){
//随机产生算术表达式
Stringexpression=random.nextInt(10)+""+operators[random.nextInt(4)]+(random.nextInt(10)+1);
Client.send(expression);
try{
Thread.currentThread().sleep(random.nextInt(1000));
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}).start();
}
}

其中一次的运行结果:


服务器已启动,端口号:12345
算术表达式为:4-2
服务器收到消息:4-2
___结果为:2
算术表达式为:5-10
服务器收到消息:5-10
___结果为:-5
算术表达式为:0-9
服务器收到消息:0-9
___结果为:-9
算术表达式为:0+6
服务器收到消息:0+6
___结果为:6
算术表达式为:1/6
服务器收到消息:1/6
___结果为:0.16666666666666666
...

从以上代码,很容易看出,BIO主要的问题在于每当有一个新的客户端请求接入时,服务端必须创建一个新的线程来处理这条链路,在需要满足高性能、高并发的场景是没法应用的(大量创建新的线程会严重影响服务器性能,甚至罢工)。


2.2、伪异步I/O编程

为了改进这种一连接一线程的模型,我们可以使用线程池来管理这些线程(需要了解更多请参考前面提供的文章),实现1个或多个线程处理N个客户端的模型(但是底层还是使用的同步阻塞I/O),通常被称为“伪异步I/O模型“。


伪异步I/O模型图:


02


实现很简单,我们只需要将新建线程的地方,交给线程池管理即可,只需要改动刚刚的Server代码即可:


packagecom.anxpp.io.calculator.bio;
importjava.io.IOException;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
/**
*BIO服务端源码__伪异步I/O
*@authoryangtao__anxpp.com
*@version1.0
*/
publicfinalclassServerBetter{
//默认的端口号
privatestaticintDEFAULT_PORT=12345;
//单例的ServerSocket
privatestaticServerSocketserver;
//线程池懒汉式的单例
privatestaticExecutorServiceexecutorService=Executors.newFixedThreadPool(60);
//根据传入参数设置监听端口,如果没有参数调用以下方法并使用默认值
publicstaticvoidstart()throwsIOException{
//使用默认值
start(DEFAULT_PORT);
}
//这个方法不会被大量并发访问,不太需要考虑效率,直接进行方法同步就行了
publicsynchronizedstaticvoidstart(intport)throwsIOException{
if(server!=null)return;
try{
//通过构造函数创建ServerSocket
//如果端口合法且空闲,服务端就监听成功
server=newServerSocket(port);
System.out.println("服务器已启动,端口号:"+port);
//通过无线循环监听客户端连接
//如果没有客户端接入,将阻塞在accept操作上。
while(true){
Socketsocket=server.accept();
//当有新的客户端接入时,会执行下面的代码
//然后创建一个新的线程处理这条Socket链路
executorService.execute(newServerHandler(socket));
}
}finally{
//一些必要的清理工作
if(server!=null){
System.out.println("服务器已关闭。");
server.close();
server=null;
}
}
}
}

测试运行结果是一样的。


我们知道,如果使用CachedThreadPool线程池(不限制线程数量,如果不清楚请参考文首提供的文章),其实除了能自动帮我们管理线程(复用),看起来也就像是1:1的客户端:线程数模型,而使用FixedThreadPool我们就有效的控制了线程的最大数量,保证了系统有限的资源的控制,实现了N:M的伪异步I/O模型。


但是,正因为限制了线程数量,如果发生大量并发请求,超过最大数量的线程就只能等待,直到线程池中的有空闲的线程可以被复用。而对Socket的输入流就行读取时,会一直阻塞,直到发生:

有数据可读
可用数据以及读取完毕
发生空指针或I/O异常

所以在读取数据较慢时(比如数据量大、网络传输慢等),大量并发的情况下,其他接入的消息,只能一直等待,这就是最大的弊端。


而后面即将介绍的NIO,就能解决这个难题。


3、NIO 编程

JDK 1.4中的java.nio.*包中引入新的Java I/O库,其目的是提高速度。实际上,“旧”的I/O包已经使用NIO重新实现过,即使我们不显式的使用NIO编程,也能从中受益。速度的提高在文件I/O和网络I/O中都可能会发生,但本文只讨论后者。



IO
NIO


面向流
面向缓冲


阻塞IO
非阻塞IO



选择器



3.1、简介

NIO我们一般认为是New I/O(也是官方的叫法),因为它是相对于老的I/O类库新增的(其实在JDK 1.4中就已经被引入了,但这个名词还会继续用很久,即使它们在现在看来已经是“旧”的了,所以也提示我们在命名时,需要好好考虑),做了很大的改变。但民间跟多人称之为Non-block I/O,即非阻塞I/O,因为这样叫,更能体现它的特点。而下文中的NIO,不是指整个新的I/O库,而是非阻塞I/O。


NIO提供了与传统BIO模型中的Socket和ServerSocket相对应的SocketChannel和ServerSocketChannel两种不同的套接字通道实现。


新增的着两种通道都支持阻塞和非阻塞两种模式。


阻塞模式使用就像传统中的支持一样,比较简单,但是性能和可靠性都不好;非阻塞模式正好与之相反。


对于低负载、低并发的应用程序,可以使用同步阻塞I/O来提升开发速率和更好的维护性;对于高负载、高并发的(网络)应用,应使用NIO的非阻塞模式来开发。


下面会先对基础知识进行介绍。


3.2、工作原理

这里写图片描述


3.3、缓冲区 Buffer

Buffer是一个对象,包含一些要写入或者读出的数据。


在NIO库中,所有数据都是用缓冲区处理的。在读取数据时,它是直接读到缓冲区中的;在写入数据时,也是写入到缓冲区中。任何时候访问NIO中的数据,都是通过缓冲区进行操作。


缓冲区实际上是一个数组,并提供了对数据结构化访问以及维护读写位置等信息。


具体的缓存区有这些:ByteBuffe、CharBuffer、 ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer。他们实现了相同的接口:Buffer。


Buffer的基本用法


使用Buffer读写数据一般遵循以下四个步骤:

写入数据到Buffer
调用flip()方法
从Buffer中读取数据
调用clear()方法或者compact()方法

当向buffer写入数据时,buffer会记录下写了多少数据。一旦要读取数据,需要通过 flip() 方法将 Buffer 从写模式切换到读模式。在读模式下,可以读取之前写入到buffer的所有数据。


一旦读完了所有的数据,就需要清空缓冲区,让它可以再次被写入。有两种方式能清空缓冲区:调用clear() 或 compact() 方法。clear() 方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处,新写入的数据将放到缓冲区未读数据的后面。


程序清单 1-1
RandomAccessFile aFile = new RandomAccessFile("d://ay.txt", "rw");
FileChannel fileChannel = aFile.getChannel();
//分配缓存区大小
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = fileChannel.read(buf);
while (bytesRead != -1) {
System.out.println("Read " + bytesRead);
//buf.flip()的调用,首先读取数据到Buffer,然后反转Buffer,接着再从Buffer中读取数据(注:flip:空翻,反转)
buf.flip();
//判断是否有剩余(注:Remaining:剩余的)
while(buf.hasRemaining()){
System.out.print((char) buf.get());
}
buf.clear();
bytesRead = fileChannel.read(buf);
}
aFile.close();

Buffer的三个属性


为了理解Buffer的工作原理,需要熟悉它的三个属性:

capacity:作为一个内存块,Buffer 有一个固定的大小值,也叫 “capacity”. 你只能往里写 capacity 个 byte、long,char 等类型。一旦 Buffer 满了,需要将其清空(通过读数据或者清除数据)才能继续写数据往里写数据。
position:当你写数据到Buffer中时,position表示当前的位置。初始的position值为0.当一个byte、long等数据写到Buffer后, position会向前移动到下一个可插入数据的 Buffer 单元。position 最大可为 capacity – 1。 当读取数据时,也是从某个特定位置读。当将 Buffer 从写模式切换到读模式,position会被重置为 0。当从Buffer的 position 处读取数据时,position 向前移动到下一个可读的位置。
limit:在写模式下,Buffer的limit表示你最多能往 Buffer 里写多少数据。写模式下,limit 等于 Buffer 的 capacity 。 当切换Buffer到读模式时, limit 表示你最多能读到多少数据。因此,当切换Buffer到读模式时,limit 会被设置成写模式下的 position 值。换句话说,你能读到之前写入的所有数据(limit被设置成已写数据的数量,这个值在写模式下就是 position )。

这里写图片描述


Buffer的类型


Java NIO 有以下Buffer类型:

ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

Buffer的分配


要想获得一个Buffer对象首先要进行分配。 每一个Buffer类都有一个allocate方法。下面是一个分配48字节capacity的ByteBuffer的例子。


ByteBuffer buf = ByteBuffer.allocate(48);

这是分配一个可存储1024个字符的CharBuffer:


CharBuffer buf = CharBuffer.allocate(1024);

Buffer写数据


写数据到Buffer有两种方式:

从Channel写到Buffer。
通过Buffer的put()方法写到Buffer里。

从Channel写到Buffer,例如:


int bytesRead = inChannel.read(buf); //read into buffer

通过put方法写Buffer的例子:


buf.put(127);

put方法有很多版本,允许你以不同的方式把数据写入到Buffer中。例如, 写到一个指定的位置,或者把一个字节数组写入到Buffer。 更多Buffer实现的细节参考JavaDoc。


flip()方法


flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0,并将limit设置成之前position的值。


换句话说,position现在用于标记读的位置,limit表示之前写进了多少个byte、char等 —— 现在能读取多少个byte、char等。


Buffer中读取数据


从Buffer中读取数据有两种方式:

从Buffer读取数据到Channel。
使用get()方法从Buffer中读取数据。

从Buffer读取数据到Channel的例子:


//read from buffer into channel.
int bytesWritten = inChannel.write(buf);

使用get()方法从Buffer中读取数据的例子 :


byte aByte = buf.get();

get方法有很多版本,允许你以不同的方式从Buffer中读取数据。例如,从指定position读取,或者从Buffer中读取数据到字节数组。


rewind()方法


Buffer.rewind()将 position 设回0,所以你可以重读Buffer中的所有数据。limit 保持不变,仍然表示能从Buffer中读取多少个元素(byte、char等)


clear()与compact()方法


一旦读完Buffer中的数据,需要让Buffer准备好再次被写入。可以通过clear()或compact()方法来完成。


如果调用的是 clear() 方法,position将被设回 0,limit被设置成 capacity 的值。换句话说,Buffer 被清空了。


如果Buffer中有一些未读的数据,调用clear()方法,数据将“被遗忘”,意味着不再有任何标记会告诉你哪些数据被读过,哪些还没有。


如果Buffer中仍有未读的数据,且后续还需要这些数据,但是此时想要先先写些数据,那么使用compact()方法。


compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit 属性依然像 clear() 方法一样,设置成 capacity。现在Buffer准备好写数据了,但是不会覆盖未读的数据。


mark()与reset()方法


通过调用Buffer.mark()方法,可以标记Buffer中的一个特定position。之后可以通过调用Buffer.reset()方法恢复到这个position。例如:


buffer.mark();
//set position back to mark.
buffer.reset();
equals()与compareTo()方法

可以使用equals()和compareTo()方法两个Buffer。


equals()


当满足下列条件时,表示两个Buffer相等:

有相同的类型(byte、char、int等)。
Buffer中剩余的 byte、char 等的个数相等。
Buffer中所有剩余的byte、char等都相同。

如你所见,equals只是比较Buffer的一部分,不是每一个在它里面的元素都比较。实际上,它只比较Buffer中的剩余元素。


compareTo()方法


compareTo()方法比较两个Buffer的剩余元素(byte、char等), 如果满足下列条件,则认为一个Buffer “小于” 另一个Buffer:

第一个不相等的元素小于另一个Buffer中对应的元素。
所有元素都相等,但第一个Buffer比另一个先耗尽(第一个Buffer的元素个数比另一个少) 3.4、通道 Channel

我们对数据的读取和写入要通过Channel,它就像水管一样,是一个通道。通道不同于流的地方就是通道是双向的,可以用于读、写和同时读写操作。


底层的操作系统的通道一般都是全双工的,所以全双工的Channel比流能更好的映射底层操作系统的API。


Channel主要分两大类:

SelectableChannel:用户网络读写
FileChannel:用于文件操作

后面代码会涉及的ServerSocketChannel和SocketChannel都是SelectableChannel的子类。


Channel主要分类


广义上来说通道可以被分为两类:File I/O和Stream I/O,也就是文件通道和套接字通道。如果分的更细致一点则是:

FileChannel 从文件读写数据
SocketChannel 通过TCP读写网络数据
ServerSocketChannel 可以监听新进来的TCP连接,并对每个链接创建对应的SocketChannel
DatagramChannel 通过UDP读写网络中的数据
Pipe

Channel的实现


这些是Java NIO中最重要的通道的实现:

FileChannel:从文件中读写数据。
DatagramChannel:能通过UDP读写网络中的数据。
SocketChannel:能通过TCP读写网络中的数据。
ServerSocketChannel:可以监听新进来的TCP连接,像Web服务器那样。对每一个新进来的连接都会创建一个SocketChannel。

打开FileChannel


在使用FileChannel之前,必须先打开它。但是,我们无法直接打开一个FileChannel,需要通过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。下面是通过RandomAccessFile打开FileChannel的示例:


RandomAccessFile aFile = new RandomAccessFile("d://nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();

FileChannel读取数据


调用多个read()方法之一从FileChannel中读取数据。如:


ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf);

首先,分配一个Buffer。从FileChannel中读取的数据将被读到Buffer中。


然后,调用FileChannel.read()方法。该方法将数据从FileChannel读取到Buffer中。read()方法返回的int值表示了有多少字节被读到了Buffer中。如果返回-1,表示到了文件末尾。


向FileChannel写数据


使用FileChannel.write()方法向FileChannel写数据,该方法的参数是一个Buffer。如:


String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
channel.write(buf);
}

注意FileChannel.write()是在while循环中调用的。因为无法保证write()方法一次能向FileChannel写入多少字节,因此需要重复调用write()方法,直到Buffer中已经没有尚未写入通道的字节。


关闭FileChannel


用完FileChannel后必须将其关闭。如:


channel.close();

FileChannel的position方法


有时可能需要在FileChannel的某个特定位置进行数据的读/写操作。可以通过调用position()方法获取FileChannel的当前位置。


也可以通过调用position(long pos)方法设置FileChannel的当前位置。


这里有两个例子:


long pos = channel.position();
channel.position(pos +123);

如果将位置设置在文件结束符之后,然后试图从文件通道中读取数据,读方法将返回-1 —— 文件结束标志。


如果将位置设置在文件结束符之后,然后向通道中写数据,文件将撑大到当前位置并写入数据。这可能导致“文件空洞”,磁盘上物理文件中写入的数据间有空隙。


FileChannel的size方法


FileChannel实例的size()方法将返回该实例所关联文件的大小。如:


long fileSize = channel.size();

FileChannel的truncate方法


可以使用FileChannel.truncate()方法截取一个文件。截取文件时,文件将中指定长度后面的部分将被删除。如:


channel.truncate(1024);

这个例子截取文件的前1024个字节。


FileChannel的force方法


FileChannel.force()方法将通道里尚未写入磁盘的数据强制写到磁盘上。出于性能方面的考虑,操作系统会将数据缓存在内存中,所以无法保证写入到FileChannel里的数据一定会即时写到磁盘上。要保证这一点,需要调用force()方法。


force()方法有一个boolean类型的参数,指明是否同时将文件元数据(权限信息等)写到磁盘上。


下面的例子同时将文件数据和元数据强制写到磁盘上:


channel.force(true);

transferFrom()


FileChannel无法设置为非阻塞模式,它总是运行在阻塞模式下。


FileChannel的transferFrom()方法可以将数据从源通道传输到FileChannel中(译者注:这个方法在JDK文档中的解释为将字节从给定的可读取字节通道传输到此通道的文件中)。下面是一个简单的例子:


//在使用FileChannel之前,必须先打开它。但是,我们无法直接打开一个FileChannel,
//需要通过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。
RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannelfromChannel = fromFile.getChannel();
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChanneltoChannel = toFile.getChannel();
long position = 0;
long count = fromChannel.size();
toChannel.transferFrom(position, count, fromChannel);

transferFrom 方法的输入参数 position 表示从 position 处开始向目标文件写入数据,count 表示最多传输的字节数。如果源通道的剩余空间小于 count 个字节,则所传输的字节数要小于请求的字节数。


此外要注意,在 SoketChannel 的实现中,SocketChannel 只会传输此刻准备好的数据(可能不足count字节)。因此,SocketChannel 可能不会将请求的所有数据(count个字节)全部传输到 FileChannel 中。


transferTo()


transferTo()方法将数据从FileChannel传输到其他的channel中。下面是一个简单的例子:


RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannelfromChannel = fromFile.getChannel();
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChanneltoChannel = toFile.getChannel();
long position = 0;
long count = fromChannel.size();
fromChannel.transferTo(position, count, toChannel);

是不是发现这个例子和前面那个例子特别相似?除了调用方法的FileChannel对象不一样外,其他的都一样。


上面所说的关于SocketChannel的问题在transferTo()方法中同样存在。SocketChannel会一直传输数据直到目标buffer被填满。


Channel简单实例


下面是Channel的一个简单的实例:


程序清单 1-1
RandomAccessFile aFile = new RandomAccessFile("d://ay.txt", "rw");
FileChannel fileChannel = aFile.getChannel();
//分配缓存区大小
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = fileChannel.read(buf);
while (bytesRead != -1) {
System.out.println("Read " + bytesRead);
//buf.flip()的调用,首先读取数据到Buffer,然后反转Buffer,接着再从Buffer中读取数据(注:flip:空翻,反转)
buf.flip();
//判断是否有剩余(注:Remaining:剩余的)
while(buf.hasRemaining()){
System.out.print((char) buf.get());
}
buf.clear();
bytesRead = fileChannel.read(buf);
}
aFile.close();
3.5、多路复用器 Selector

Selector是Java NIO 编程的基础。


Selector提供选择已经就绪的任务的能力:Selector会不断轮询注册在其上的Channel,如果某个Channel上面发生读或者写事件,这个Channel就处于就绪状态,会被Selector轮询出来,然后通过SelectionKey可以获取就绪Channel的集合,进行后续的I/O操作。


一个Selector可以同时轮询多个Channel,因为JDK使用了epoll()代替传统的select实现,所以没有最大连接句柄1024/2048的限制。所以,只需要一个线程负责Selector的轮询,就可以接入成千上万的客户端。


Java NIO引入了选择器的概念,选择器用于监听多个通道的事件(比如:连接打开,数据到达)。Selector提供选择已经就绪的任务的能力:Selector会不断轮询注册在其上的Channel,如果某个Channel上面发生读或者写事件,这个Channel就处于就绪状态,会被Selector轮询出来,然后通过SelectionKey可以获取就绪Channel的集合,进行后续的I/O操作。


一个Selector可以同时轮询多个Channel,因为JDK使用了epoll()代替传统的select实现,所以没有最大连接句柄1024/2048的限制。所以,只需要一个线程负责Selector的轮询,就可以接入成千上万的客户端。


这里写图片描述


要使用Selector,得向 Selector 注册 Channel ,然后调用它的 select() 方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回,线程就可以处理这些事件,事件的例子比如新连接进来,数据接收等。


Selector的创建


通过调用Selector.open()方法创建一个Selector,如下:


Selector selector = Selector.open();

​​​​​​Selector注册通道


为了将 Channel 和 Selector 配合使用,必须将 channel 注册到 selector 上。通过 SelectableChannel.register() 方法来实现,如下:


channel.configureBlocking(false);
SelectionKey key = channel.register(selector,Selectionkey.OP_READ);

与 Selector 一起使用时,Channel 必须处于非阻塞模式下。这意味着不能将 FileChannel 与 Selector 一起使用,因为 FileChannel 不能切换到非阻塞模式。而套接字通道都可以。


注意register()方法的第二个参数。这是一个“interest集合”,意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件:

Connect
Accept
Read
Write

通道触发了一个事件意思是该事件已经就绪。所以,某个channel成功连接到另一个服务器称为“连接就绪”。一个 server socket channel 准备好接收新进入的连接称为“接收就绪”。一个有数据可读的通道可以说是“读就绪”。等待写数据的通道可以说是“写就绪”。


这四种事件用 SelectionKey 的四个常量来表示:

SelectionKey.OP_CONNECT
SelectionKey.OP_ACCEPT
SelectionKey.OP_READ
SelectionKey.OP_WRITE

如果你对不止一种事件感兴趣,那么可以用 “ 位 或 ” 操作符将常量连接起来,如下:


int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey


在上一小节中,当向Selector注册Channel时,register() 方法会返回一个SelectionKey对象。这个对象包含了一些你感兴趣的属性:

interest集合
ready集合
Channel
Selector
附加的对象(可选)

下面我会描述这些属性。


interest集合


就像向Selector注册通道一节中所描述的,interest集合是你所选择的感兴趣的事件集合。可以通过 SelectionKey 读写 interest 集合,像这样:


int interestSet = selectionKey.interestOps();
boolean isInterestedInAccept= (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT;
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead= interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite = interestSet & SelectionKey.OP_WRITE;

可以看到,用“位与”操作interest 集合和给定的 SelectionKey 常量,可以确定某个确定的事件是否在 interest 集合中。


ready集合


ready 集合是通道已经准备就绪的操作的集合。在一次选择(Selection)之后,你会首先访问这个readySet。Selection将在下一小节进行解释。可以这样访问ready集合:


int readySet = selectionKey.readyOps();

可以用像检测 interest 集合那样的方法,来检测channel中什么事件或操作已经就绪。但是,也可以使用以下四个方法,它们都会返回一个布尔类型:


selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

Channel + Selector


从SelectionKey访问Channel和Selector很简单。如下:


Channelchannel= selectionKey.channel();
Selector selector = selectionKey.selector();

附加的对象


可以将一个对象或者更多信息附着到SelectionKey上,这样就能方便的识别某个给定的通道。例如,可以附加 与通道一起使用的Buffer,或是包含聚集数据的某个对象。使用方法如下:


selectionKey.attach(theObject);
Object attachedObj = selectionKey.attachment();

还可以在用register()方法向Selector注册Channel的时候附加对象。如:


SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

通过Selector选择通道


一旦向Selector注册了一或多个通道,就可以调用几个重载的select()方法。这些方法返回你所感兴趣的事件(如连接、接受、读或写)已经准备就绪的那些通道。换句话说,如果你对“读就绪”的通道感兴趣,select()方法会返回读事件已经就绪的那些通道。


下面是select()方法:

int select()
int select(long timeout)
int selectNow()

select()阻塞到至少有一个通道在你注册的事件上就绪了。


select(long timeout) 和 select() 一样,除了最长会阻塞 timeout 毫秒(参数)。


selectNow() 不会阻塞,不管什么通道就绪都立刻返回(译者注:此方法执行非阻塞的选择操作。如果自从前一次选择操作后,没有通道变成可选择的,则此方法直接返回零。)。


select()方法返回的int值表示有多少通道已经就绪。亦即,自上次调用select()方法后有多少通道变成就绪状态。如果调用select()方法,因为有一个通道变成就绪状态,返回了1,若再次调用select()方法,如果另一个通道就绪了,它会再次返回1。如果对第一个就绪的channel没有做任何操作,现在就有两个就绪的通道,但在每次select()方法调用之间,只有一个通道就绪了。


selectedKeys()


一旦调用了select()方法,并且返回值表明有一个或更多个通道就绪了,然后可以通过调用selector的selectedKeys()方法,访问“已选择键集(selected key set)”中的就绪通道。如下所示:


Set selectedKeys = selector.selectedKeys();

当向 Selector 注册 Channel 时,Channel.register() 方法会返回一个 SelectionKey 对象。这个对象代表了注册到该Selector的通道。可以通过SelectionKey的selectedKeySet()方法访问这些对象。


可以遍历这个已选择的键集合来访问就绪的通道。如下:


Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if(key.isAcceptable()) {
// a connection was accepted by a ServerSocketChannel.
} else if (key.isConnectable()) {
// a connection was established with a remote server.
} else if (key.isReadable()) {
// a channel is ready for reading
} else if (key.isWritable()) {
// a channel is ready for writing
}
keyIterator.remove();
}

这个循环遍历已选择键集中的每个键,并检测各个键所对应的通道的就绪事件。


注意每次迭代末尾的 keyIterator.remove() 调用。Selector不会自己从已选择键集中移除 SelectionKey 实例。必须在处理完通道时自己移除。下次该通道变成就绪时,Selector会再次将其放入已选择键集中。


SelectionKey.channel() 方法返回的通道需要转型成你要处理的类型,如 ServerSocketChannel 或 SocketChannel 等。


wakeUp()


某个线程调用select()方法后阻塞了,即使没有通道已经就绪,也有办法让其从select()方法返回。只要让其它线程在第一个线程调用select()方法的那个对象上调用Selector.wakeup()方法即可。阻塞在select()方法上的线程会立马返回。


如果有其它线程调用了wakeup()方法,但当前没有线程阻塞在select()方法上,下个调用select()方法的线程会立即“醒来(wake up)”。


close()


用完 Selector 后调用其 close() 方法会关闭该 Selector,且使注册到该Selector上的所有SelectionKey实例无效。通道本身并不会关闭。


完整的示例


这里有一个完整的示例,打开一个Selector,注册一个通道注册到这个Selector上(通道的初始化过程略去),然后持续监控这个Selector的四种事件(接受,连接,读,写)是否就绪。


Selector selector = Selector.open();
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
while(true) {
int readyChannels = selector.select();
if(readyChannels == 0) continue;
Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if(key.isAcceptable()) {
// a connection was accepted by a ServerSocketChannel.
} else if (key.isConnectable()) {
// a connection was established with a remote server.
} else if (key.isReadable()) {
// a channel is ready for reading
} else if (key.isWritable()) {
// a channel is ready for writing
}
keyIterator.remove();
}
}

分散(Scatter)/聚集(Gather)


分散概念


分散(scatter):从Channel中读取是指在读操作时将读取的数据写入多个buffer中。因此,Channel将从Channel中读取的数据“分散(scatter)”到多个Buffer中。


这里写图片描述


程序清单 1-1
ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
ByteBuffer[] bufferArray = { header, body };
channel.read(bufferArray);

注意buffer首先被插入到数组,然后再将数组作为 channel.read() 的输入参数。read() 方法按照 buffer 在数组中的顺序将从 channel 中读取的数据写入到buffer,当一个 buffer 被写满后,channel 紧接着向另一个 buffer 中写。


Scattering Reads在移动下一个buffer前,必须填满当前的buffer,这也意味着它不适用于动态消息(译者注:消息大小不固定)。换句话说,如果存在消息头和消息体,消息头必须完成填充(例如 128byte),Scattering Reads才能正常工作。


聚集概念


这里写图片描述


聚集(gather):写入Channel是指在写操作时将多个buffer的数据写入同一个Channel,因此,Channel 将多个Buffer中的数据“聚集(gather)”后发送到Channel。


示例1-1
ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
//write data into buffers
ByteBuffer[] bufferArray = { header, body };
channel.write(bufferArray);

buffer的一个数组被传递给了 write() 方法,这个方法写他们在数组中遇到的接下来的 buffer 的内容。只是这些数据在 buffer 的 position 和 limit 直接被写。因此,如果一个buffer有一个128字节的容量,但是只包含了58个字节,只有58个字节可以从 buffer 中写到 channel 。因此,一个聚集写操作通过动态可变大小的消息部分会工作的很好,跟分散读取正好相反。


分散/聚集的应用


scatter / gather经常用于需要将传输的数据分开处理的场合。例如,您可能在编写一个使用消息对象的网络应用程序,每一个消息被划分为固定长度的头部和固定长度的正文。您可以创建一个刚好可以容纳头部的缓冲区和另一个刚好可以容纳正文的缓冲区。当您将它们放入一个数组中并使用分散读取来向它们读入消息时,头部和正文将整齐地划分到这两个缓冲区中。


我们从缓冲区所得到的方便性对于缓冲区数组同样有效。因为每一个缓冲区都跟踪自己还可以接受多少数据,所以分散读取会自动找到有空间接受数据的第一个缓冲区。在这个缓冲区填满后,它就会移动到下一个缓冲区。


简单小例子


RandomAccessFile raf1=new RandomAccessFile("d://ay.txt", "rw");
//获取通道
FileChannel channel1 = raf1.getChannel();
//设置缓冲区
ByteBuffer buf1=ByteBuffer.allocate(50);
ByteBuffer buf2=ByteBuffer.allocate(1024);
//分散读取的时候缓存区应该是有序的,所以把几个缓冲区加入数组中
ByteBuffer[] bufs={buf1,buf2};
//通道进行传输
channel1.read(bufs);
//查看缓冲区中的内容
for (int i = 0; i < bufs.length; i++) {
//切换为读模式
bufs[i].flip();
}
System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));
System.out.println();
System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));
//聚集写入
RandomAccessFileraf2=new RandomAccessFile("d://al.txt", "rw");
FileChannel channel2 = raf2.getChannel();
//只能通过通道来进行写入
channel2.write(bufs);

Socket管道


Java NIO中的 SocketChannel 是一个连接到 TCP 网络套接字的通道。可以通过以下2种方式创建 SocketChannel:

打开一个SocketChannel并连接到互联网上的某台服务器。
一个新连接到达 ServerSocketChannel 时,会创建一个 SocketChannel。

打开 SocketChannel


下面是SocketChannel的打开方式:


SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("http://jenkov.com",80));

从 SocketChannel 读取数据


要从SocketChannel中读取数据,调用一个read()的方法之一。以下是例子:


ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = socketChannel.read(buf);

首先,分配一个Buffer。从SocketChannel读取到的数据将会放到这个Buffer中。


然后,调用SocketChannel.read()。该方法将数据从SocketChannel 读到Buffer中。read()方法返回的int值表示读了多少字节进Buffer里。如果返回的是-1,表示已经读到了流的末尾(连接关闭了)。


写入 SocketChannel


写数据到SocketChannel用的是SocketChannel.write()方法,该方法以一个Buffer作为参数。示例如下:


String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
channel.write(buf);
}

注意SocketChannel.write()方法的调用是在一个while循环中的。Write()方法无法保证能写多少字节到SocketChannel。所以,我们重复调用write()直到Buffer没有要写的字节为止。


非阻塞模式


可以设置 SocketChannel 为非阻塞模式(non-blocking mode).设置之后,就可以在异步模式下调用connect(), read() 和write()了。


connect()


如果SocketChannel在非阻塞模式下,此时调用connect(),该方法可能在连接建立之前就返回了。为了确定连接是否建立,可以调用finishConnect()的方法。像这样:


socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress("http://jenkov.com", 80));
while(! socketChannel.finishConnect() ){
//wait, or do something else...
}

write()


非阻塞模式下,write()方法在尚未写出任何内容时可能就返回了。所以需要在循环中调用write()。前面已经有例子了,这里就不赘述了。


read()


非阻塞模式下,read()方法在尚未读取到任何数据时可能就返回了。所以需要关注它的int返回值,它会告诉你读取了多少字节。


不错的小例子


一下是来自网络的一个小例子,个人觉得很不错,就贴到这里。


class NioClient {
//管道管理器
private Selector selector;
public NioClient init(String serverIp, int port) throws IOException{
//获取socket通道
SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false);
//获得通道管理器
selector=Selector.open();
//客户端连接服务器,需要调用channel.finishConnect();才能实际完成连接。
channel.connect(new InetSocketAddress(serverIp, port));
//为该通道注册SelectionKey.OP_CONNECT事件
channel.register(selector, SelectionKey.OP_CONNECT);
return this;
}
public void listen() throws IOException{
System.out.println("客户端启动");
//轮询访问selector
while(true){
//选择注册过的io操作的事件(第一次为SelectionKey.OP_CONNECT)
selector.select();
Iterator ite = selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = ite.next();
//删除已选的key,防止重复处理
ite.remove();
if(key.isConnectable()){
SocketChannel channel=(SocketChannel)key.channel();
//如果正在连接,则完成连接
if(channel.isConnectionPending()){
channel.finishConnect();
}
channel.configureBlocking(false);
//向服务器发送消息
channel.write(ByteBuffer.wrap(new String("send message to server.").getBytes()));
//连接成功后,注册接收服务器消息的事件
channel.register(selector, SelectionKey.OP_READ);
System.out.println("客户端连接成功");
}else if(key.isReadable()){ //有可读数据事件。
SocketChannel channel = (SocketChannel)key.channel();
ByteBuffer buffer = ByteBuffer.allocate(10);
channel.read(buffer);
byte[] data = buffer.array();
String message = new String(data);
System.out.println("recevie message from server:, size:" + buffer.position() + " msg: " + message);
//ByteBuffer outbuffer = ByteBuffer.wrap(("client.".concat(msg)).getBytes());
//channel.write(outbuffer);
}
}
}
}
public static void main(String[] args) throws IOException {
new NioClient().init("127.0.0.1", 9981).listen();
}
}class NioServer {
//通道管理器
private Selector selector;
//获取一个ServerSocket通道,并初始化通道
public NioServer init(int port) throws IOException{
//获取一个ServerSocket通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.socket().bind(new InetSocketAddress(port));
//获取通道管理器
selector=Selector.open();
//将通道管理器与通道绑定,并为该通道注册SelectionKey.OP_ACCEPT事件,
//只有当该事件到达时,Selector.select()会返回,否则一直阻塞。
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
return this;
}
public void listen() throws IOException{
System.out.println("服务器端启动成功");
//使用轮询访问selector
while(true){
//当有注册的事件到达时,方法返回,否则阻塞。
selector.select();
//获取selector中的迭代器,选中项为注册的事件
Iterator ite=selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = ite.next();
//删除已选key,防止重复处理
ite.remove();
//客户端请求连接事件
if(key.isAcceptable()){
ServerSocketChannel server = (ServerSocketChannel)key.channel();
//获得客户端连接通道
SocketChannel channel = server.accept();
channel.configureBlocking(false);
//向客户端发消息
channel.write(ByteBuffer.wrap(new String("send message to client").getBytes()));
//在与客户端连接成功后,为客户端通道注册SelectionKey.OP_READ事件。
channel.register(selector, SelectionKey.OP_READ);
System.out.println("客户端请求连接事件");
}else if(key.isReadable()){//有可读数据事件
//获取客户端传输数据可读取消息通道。
SocketChannel channel = (SocketChannel)key.channel();
//创建读取数据缓冲器
ByteBuffer buffer = ByteBuffer.allocate(10);
int read = channel.read(buffer);
byte[] data = buffer.array();
String message = new String(data);
System.out.println("receive message from client, size:" + buffer.position() + " msg: " + message);
//ByteBuffer outbuffer = ByteBuffer.wrap(("server.".concat(msg)).getBytes());
//channel.write(outbuffer);
}
}
}
}
public static void main(String[] args) throws IOException {
new NioServer().init(9981).listen();
}
}

Datagram 通道


Java NIO中的DatagramChannel是一个能收发UDP包的通道。因为UDP是无连接的网络协议,所以不能像其它通道那样读取和写入。它发送和接收的是数据包。


Datagram 通道就作为大家自学的内容。


管道(Pipe)


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


这里写图片描述


创建管道


通过Pipe.open()方法打开管道。例如:


Pipe pipe = Pipe.open();

向管道写数据


要向管道写数据,需要访问sink通道。像这样:


Pipe.SinkChannel sinkChannel = pipe.sink();

通过调用SinkChannel的write()方法,将数据写入SinkChannel,像这样:


String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
sinkChannel.write(buf);
}

从管道读取数据


从读取管道的数据,需要访问source通道,像这样:


Pipe.SourceChannel sourceChannel = pipe.source();

调用source通道的read()方法来读取数据,像这样:


ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf);

read()方法返回的int值会告诉我们多少字节被读进了缓冲区。


简单完整实例


//获取管道
Pipe pipe = Pipe.open();
//获取Sink 管道
Pipe.SinkChannel sinkChannel = pipe.sink();
//需要写入数据
String newData = "New String to write to file..." + System.currentTimeMillis();
//新建缓存区
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
//缓存区存放数据
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
sinkChannel.write(buf);
}
//获取Source 管道
Pipe.SourceChannel sourceChannel = pipe.source();
ByteBuffer buf2 = ByteBuffer.allocate(48);
int bytesRead = sourceChannel.read(buf2);
while (bytesRead != -1) {
System.out.println("Read " + bytesRead);
//buf.flip()的调用,首先读取数据到Buffer,然后反转Buffer,接着再从Buffer中读取数据(注:flip:空翻,反转)
buf.flip();
//判断是否有剩余(注:Remaining:剩余的)
while(buf.hasRemaining()){
System.out.print((char) buf.get());
}
buf.clear();
bytesRead = sourceChannel.read(buf);
}
sourceChannel.close();
sinkChannel.close();
3.6、NIO服务端

代码比传统的Socket编程看起来要复杂不少。


直接贴代码吧,以注释的形式给出代码说明。


NIO创建的Server源码:


packagecom.anxpp.io.calculator.nio;
publicclassServer{
privatestaticintDEFAULT_PORT=12345;
privatestaticServerHandleserverHandle;
publicstaticvoidstart(){
start(DEFAULT_PORT);
}
publicstaticsynchronizedvoidstart(intport){
if(serverHandle!=null)
serverHandle.stop();
serverHandle=newServerHandle(port);
newThread(serverHandle,"Server").start();
}
publicstaticvoidmain(String[]args){
start();
}
}

ServerHandle:


packagecom.anxpp.io.calculator.nio;
importjava.io.IOException;
importjava.net.InetSocketAddress;
importjava.nio.ByteBuffer;
importjava.nio.channels.SelectionKey;
importjava.nio.channels.Selector;
importjava.nio.channels.ServerSocketChannel;
importjava.nio.channels.SocketChannel;
importjava.util.Iterator;
importjava.util.Set;
importcom.anxpp.io.utils.Calculator;
/**
*NIO服务端
*@authoryangtao__anxpp.com
*@version1.0
*/
publicclassServerHandleimplementsRunnable{
privateSelectorselector;
privateServerSocketChannelserverChannel;
privatevolatilebooleanstarted;
/**
*构造方法
*@paramport指定要监听的端口号
*/
publicServerHandle(intport){
try{
//创建选择器
selector=Selector.open();
//打开监听通道
serverChannel=ServerSocketChannel.open();
//如果为true,则此通道将被置于阻塞模式;如果为false,则此通道将被置于非阻塞模式
serverChannel.configureBlocking(false);//开启非阻塞模式
//绑定端口backlog设为1024
serverChannel.socket().bind(newInetSocketAddress(port),1024);
//监听客户端连接请求
serverChannel.register(selector,SelectionKey.OP_ACCEPT);
//标记服务器已开启
started=true;
System.out.println("服务器已启动,端口号:"+port);
}catch(IOExceptione){
e.printStackTrace();
System.exit(1);
}
}
publicvoidstop(){
started=false;
}
@Override
publicvoidrun(){
//循环遍历selector
while(started){
try{
//无论是否有读写事件发生,selector每隔1s被唤醒一次
selector.select(1000);
//阻塞,只有当至少一个注册的事件发生的时候才会继续.
//selector.select();
Setkeys=selector.selectedKeys();
Iteratorit=keys.iterator();
SelectionKeykey=null;
while(it.hasNext()){
key=it.next();
it.remove();
try{
handleInput(key);
}catch(Exceptione){
if(key!=null){
key.cancel();
if(key.channel()!=null){
key.channel().close();
}
}
}
}
}catch(Throwablet){
t.printStackTrace();
}
}
//selector关闭后会自动释放里面管理的资源
if(selector!=null)
try{
selector.close();
}catch(Exceptione){
e.printStackTrace();
}
}
privatevoidhandleInput(SelectionKeykey)throwsIOException{
if(key.isValid()){
//处理新接入的请求消息
if(key.isAcceptable()){
ServerSocketChannelssc=(ServerSocketChannel)key.channel();
//通过ServerSocketChannel的accept创建SocketChannel实例
//完成该操作意味着完成TCP三次握手,TCP物理链路正式建立
SocketChannelsc=ssc.accept();
//设置为非阻塞的
sc.configureBlocking(false);
//注册为读
sc.register(selector,SelectionKey.OP_READ);
}
//读消息
if(key.isReadable()){
SocketChannelsc=(SocketChannel)key.channel();
//创建ByteBuffer,并开辟一个1M的缓冲区
ByteBufferbuffer=ByteBuffer.allocate(1024);
//读取请求码流,返回读取到的字节数
intreadBytes=sc.read(buffer);
//读取到字节,对字节进行编解码
if(readBytes>0){
//将缓冲区当前的limit设置为position=0,用于后续对缓冲区的读取操作
buffer.flip();
//根据缓冲区可读字节数创建字节数组
byte[]bytes=newbyte[buffer.remaining()];
//将缓冲区可读字节数组复制到新建的数组中
buffer.get(bytes);
Stringexpression=newString(bytes,"UTF-8");
System.out.println("服务器收到消息:"+expression);
//处理数据
Stringresult=null;
try{
result=Calculator.cal(expression).toString();
}catch(Exceptione){
result="计算错误:"+e.getMessage();
}
//发送应答消息
doWrite(sc,result);
}
//没有读取到字节忽略
//elseif(readBytes==0);
//链路已经关闭,释放资源
elseif(readBytes<0){
key.cancel();
sc.close();
}
}
}
}
//异步发送应答消息
privatevoiddoWrite(SocketChannelchannel,Stringresponse)throwsIOException{
//将消息编码为字节数组
byte[]bytes=response.getBytes();
//根据数组容量创建ByteBuffer
ByteBufferwriteBuffer=ByteBuffer.allocate(bytes.length);
//将字节数组复制到缓冲区
writeBuffer.put(bytes);
//flip操作
writeBuffer.flip();
//发送缓冲区的字节数组
channel.write(writeBuffer);
//****此处不含处理“写半包”的代码
}
}

可以看到,创建NIO服务端的主要步骤如下:


打开ServerSocketChannel,监听客户端连接
绑定监听端口,设置连接为非阻塞模式
创建Reactor线程,创建多路复用器并启动线程
将ServerSocketChannel注册到Reactor线程中的Selector上,监听ACCEPT事件
Selector轮询准备就绪的key
Selector监听到新的客户端接入,处理新的接入请求,完成TCP三次握手,简历物理链路
设置客户端链路为非阻塞模式
将新接入的客户端连接注册到Reactor线程的Selector上,监听读操作,读取客户端发送的网络消息
异步读取客户端消息到缓冲区
对Buffer编解码,处理半包消息,将解码成功的消息封装成Task
将应答消息编码为Buffer,调用SocketChannel的write将消息异步发送给客户端

因为应答消息的发送,SocketChannel也是异步非阻塞的,所以不能保证一次能吧需要发送的数据发送完,此时就会出现写半包的问题。我们需要注册写操作,不断轮询Selector将没有发送完的消息发送完毕,然后通过Buffer的hasRemain()方法判断消息是否发送完成。


3.7、NIO客户端

还是直接上代码吧,过程也不需要太多解释了,跟服务端代码有点类似。


Client:


packagecom.anxpp.io.calculator.nio;
publicclassClient{
privatestaticStringDEFAULT_HOST="127.0.0.1";
privatestaticintDEFAULT_PORT=12345;
privatestaticClientHandleclientHandle;
publicstaticvoidstart(){
start(DEFAULT_HOST,DEFAULT_PORT);
}
publicstaticsynchronizedvoidstart(Stringip,intport){
if(clientHandle!=null)
clientHandle.stop();
clientHandle=newClientHandle(ip,port);
newThread(clientHandle,"Server").start();
}
//向服务器发送消息
publicstaticbooleansendMsg(Stringmsg)throwsException{
if(msg.equals("q"))returnfalse;
clientHandle.sendMsg(msg);
returntrue;
}
publicstaticvoidmain(String[]args){
start();
}
}

ClientHandle:


packagecom.anxpp.io.calculator.nio;
importjava.io.IOException;
importjava.net.InetSocketAddress;
importjava.nio.ByteBuffer;
importjava.nio.channels.SelectionKey;
importjava.nio.channels.Selector;
importjava.nio.channels.SocketChannel;
importjava.util.Iterator;
importjava.util.Set;
/**
*NIO客户端
*@authoryangtao__anxpp.com
*@version1.0
*/
publicclassClientHandleimplementsRunnable{
privateStringhost;
privateintport;
privateSelectorselector;
privateSocketChannelsocketChannel;
privatevolatilebooleanstarted;
publicClientHandle(Stringip,intport){
this.host=ip;
this.port=port;
try{
//创建选择器
selector=Selector.open();
//打开监听通道
socketChannel=SocketChannel.open();
//如果为true,则此通道将被置于阻塞模式;如果为false,则此通道将被置于非阻塞模式
socketChannel.configureBlocking(false);//开启非阻塞模式
started=true;
}catch(IOExceptione){
e.printStackTrace();
System.exit(1);
}
}
publicvoidstop(){
started=false;
}
@Override
publicvoidrun(){
try{
doConnect();
}catch(IOExceptione){
e.printStackTrace();
System.exit(1);
}
//循环遍历selector
while(started){
try{
//无论是否有读写事件发生,selector每隔1s被唤醒一次
selector.select(1000);
//阻塞,只有当至少一个注册的事件发生的时候才会继续.
//selector.select();
Setkeys=selector.selectedKeys();
Iteratorit=keys.iterator();
SelectionKeykey=null;
while(it.hasNext()){
key=it.next();
it.remove();
try{
handleInput(key);
}catch(Exceptione){
if(key!=null){
key.cancel();
if(key.channel()!=null){
key.channel().close();
}
}
}
}
}catch(Exceptione){
e.printStackTrace();
System.exit(1);
}
}
//selector关闭后会自动释放里面管理的资源
if(selector!=null)
try{
selector.close();
}catch(Exceptione){
e.printStackTrace();
}
}
privatevoidhandleInput(SelectionKeykey)throwsIOException{
if(key.isValid()){
SocketChannelsc=(SocketChannel)key.channel();
if(key.isConnectable()){
if(sc.finishConnect());
elseSystem.exit(1);
}
//读消息
if(key.isReadable()){
//创建ByteBuffer,并开辟一个1M的缓冲区
ByteBufferbuffer=ByteBuffer.allocate(1024);
//读取请求码流,返回读取到的字节数
intreadBytes=sc.read(buffer);
//读取到字节,对字节进行编解码
if(readBytes>0){
//将缓冲区当前的limit设置为position=0,用于后续对缓冲区的读取操作
buffer.flip();
//根据缓冲区可读字节数创建字节数组
byte[]bytes=newbyte[buffer.remaining()];
//将缓冲区可读字节数组复制到新建的数组中
buffer.get(bytes);
Stringresult=newString(bytes,"UTF-8");
System.out.println("客户端收到消息:"+result);
}
//没有读取到字节忽略
//elseif(readBytes==0);
//链路已经关闭,释放资源
elseif(readBytes<0){
key.cancel();
sc.close();
}
}
}
}
//异步发送消息
privatevoiddoWrite(SocketChannelchannel,Stringrequest)throwsIOException{
//将消息编码为字节数组
byte[]bytes=request.getBytes();
//根据数组容量创建ByteBuffer
ByteBufferwriteBuffer=ByteBuffer.allocate(bytes.length);
//将字节数组复制到缓冲区
writeBuffer.put(bytes);
//flip操作
writeBuffer.flip();
//发送缓冲区的字节数组
channel.write(writeBuffer);
//****此处不含处理“写半包”的代码
}
privatevoiddoConnect()throwsIOException{
if(socketChannel.connect(newInetSocketAddress(host,port)));
elsesocketChannel.register(selector,SelectionKey.OP_CONNECT);
}
publicvoidsendMsg(Stringmsg)throwsException{
socketChannel.register(selector,SelectionKey.OP_READ);
doWrite(socketChannel,msg);
}
}
3.8、演示结果

首先运行服务器,顺便也运行一个客户端:


packagecom.anxpp.io.calculator.nio;
importjava.util.Scanner;
/**
*测试方法
*@authoryangtao__anxpp.com
*@version1.0
*/
publicclassTest{
//测试主方法
@SuppressWarnings("resource")
publicstaticvoidmain(String[]args)throwsException{
//运行服务器
Server.start();
//避免客户端先于服务器启动前执行代码
Thread.sleep(100);
//运行客户端
Client.start();
while(Client.sendMsg(newScanner(System.in).nextLine()));
}
}

我们也可以单独运行客户端,效果都是一样的。


一次测试的结果:


服务器已启动,端口号:12345
1+2+3+4+5+6
服务器收到消息:1+2+3+4+5+6
客户端收到消息:21
1*2/3-4+5*6/7-8
服务器收到消息:1*2/3-4+5*6/7-8
客户端收到消息:-7.0476190476190474

运行多个客户端,都是没有问题的。


4、AIO编程

NIO 2.0引入了新的异步通道的概念,并提供了异步文件通道和异步套接字通道的实现。


异步的套接字通道时真正的异步非阻塞I/O,对应于UNIX网络编程中的事件驱动I/O(AIO)。他不需要过多的Selector对注册的通道进行轮询即可实现异步读写,从而简化了NIO的编程模型。


NIO与AIO区别:

NIO是同步非阻塞的,AIO是异步非阻塞的
由于NIO的读写过程依然在应用线程里完成,所以对于那些读写过程时间长的,NIO就不太适合。而AIO的读写过程完成后才被通知,所以AIO能够胜任那些重量级,读写过程长的任务。

直接上代码吧。


4.1、Server端代码

Server:


packagecom.anxpp.io.calculator.aio.server;
/**
*AIO服务端
*@authoryangtao__anxpp.com
*@version1.0
*/
publicclassServer{
privatestaticintDEFAULT_PORT=12345;
privatestaticAsyncServerHandlerserverHandle;
publicvolatilestaticlongclientCount=0;
publicstaticvoidstart(){
start(DEFAULT_PORT);
}
publicstaticsynchronizedvoidstart(intport){
if(serverHandle!=null)
return;
serverHandle=newAsyncServerHandler(port);
newThread(serverHandle,"Server").start();
}
publicstaticvoidmain(String[]args){
Server.start();
}
}

AsyncServerHandler:


packagecom.anxpp.io.calculator.aio.server;
importjava.io.IOException;
importjava.net.InetSocketAddress;
importjava.nio.channels.AsynchronousServerSocketChannel;
importjava.util.concurrent.CountDownLatch;
publicclassAsyncServerHandlerimplementsRunnable{
publicCountDownLatchlatch;
publicAsynchronousServerSocketChannelchannel;
publicAsyncServerHandler(intport){
try{
//创建服务端通道
channel=AsynchronousServerSocketChannel.open();
//绑定端口
channel.bind(newInetSocketAddress(port));
System.out.println("服务器已启动,端口号:"+port);
}catch(IOExceptione){
e.printStackTrace();
}
}
@Override
publicvoidrun(){
//CountDownLatch初始化
//它的作用:在完成一组正在执行的操作之前,允许当前的现场一直阻塞
//此处,让现场在此阻塞,防止服务端执行完成后退出
//也可以使用while(true)+sleep
//生成环境就不需要担心这个问题,以为服务端是不会退出的
latch=newCountDownLatch(1);
//用于接收客户端的连接
channel.accept(this,newAcceptHandler());
try{
latch.await();
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}

AcceptHandler:


packagecom.anxpp.io.calculator.aio.server;
importjava.nio.ByteBuffer;
importjava.nio.channels.AsynchronousSocketChannel;
importjava.nio.channels.CompletionHandler;
//作为handler接收客户端连接
publicclassAcceptHandlerimplementsCompletionHandler{
@Override
publicvoidcompleted(AsynchronousSocketChannelchannel,AsyncServerHandlerserverHandler){
//继续接受其他客户端的请求
Server.clientCount++;
System.out.println("连接的客户端数:"+Server.clientCount);
serverHandler.channel.accept(serverHandler,this);
//创建新的Buffer
ByteBufferbuffer=ByteBuffer.allocate(1024);
//异步读第三个参数为接收消息回调的业务Handler
channel.read(buffer,buffer,newReadHandler(channel));
}
@Override
publicvoidfailed(Throwableexc,AsyncServerHandlerserverHandler){
exc.printStackTrace();
serverHandler.latch.countDown();
}
}

ReadHandler:


packagecom.anxpp.io.calculator.aio.server;
importjava.io.IOException;
importjava.io.UnsupportedEncodingException;
importjava.nio.ByteBuffer;
importjava.nio.channels.AsynchronousSocketChannel;
importjava.nio.channels.CompletionHandler;
importcom.anxpp.io.utils.Calculator;
publicclassReadHandlerimplementsCompletionHandler{
//用于读取半包消息和发送应答
privateAsynchronousSocketChannelchannel;
publicReadHandler(AsynchronousSocketChannelchannel){
this.channel=channel;
}
//读取到消息后的处理
@Override
publicvoidcompleted(Integerresult,ByteBufferattachment){
//flip操作
attachment.flip();
//根据
byte[]message=newbyte[attachment.remaining()];
attachment.get(message);
try{
Stringexpression=newString(message,"UTF-8");
System.out.println("服务器收到消息:"+expression);
StringcalrResult=null;
try{
calrResult=Calculator.cal(expression).toString();
}catch(Exceptione){
calrResult="计算错误:"+e.getMessage();
}
//向客户端发送消息
doWrite(calrResult);
}catch(UnsupportedEncodingExceptione){
e.printStackTrace();
}
}
//发送消息
privatevoiddoWrite(Stringresult){
byte[]bytes=result.getBytes();
ByteBufferwriteBuffer=ByteBuffer.allocate(bytes.length);
writeBuffer.put(bytes);
writeBuffer.flip();
//异步写数据参数与前面的read一样
channel.write(writeBuffer,writeBuffer,newCompletionHandler(){
@Override
publicvoidcompleted(Integerresult,ByteBufferbuffer){
//如果没有发送完,就继续发送直到完成
if(buffer.hasRemaining())
channel.write(buffer,buffer,this);
else{
//创建新的Buffer
ByteBufferreadBuffer=ByteBuffer.allocate(1024);
//异步读第三个参数为接收消息回调的业务Handler
channel.read(readBuffer,readBuffer,newReadHandler(channel));
}
}
@Override
publicvoidfailed(Throwableexc,ByteBufferattachment){
try{
channel.close();
}catch(IOExceptione){
}
}
});
}
@Override
publicvoidfailed(Throwableexc,ByteBufferattachment){
try{
this.channel.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}

OK,这样就已经完成了,其实说起来也简单,虽然代码感觉很多,但是API比NIO的使用起来真的简单多了,主要就是监听、读、写等各种CompletionHandler。此处本应有一个WriteHandler的,确实,我们在ReadHandler中,以一个匿名内部类实现了它。


下面看客户端代码。


4.2、Client端代码

Client:


packagecom.anxpp.io.calculator.aio.client;
importjava.util.Scanner;
publicclassClient{
privatestaticStringDEFAULT_HOST="127.0.0.1";
privatestaticintDEFAULT_PORT=12345;
privatestaticAsyncClientHandlerclientHandle;
publicstaticvoidstart(){
start(DEFAULT_HOST,DEFAULT_PORT);
}
publicstaticsynchronizedvoidstart(Stringip,intport){
if(clientHandle!=null)
return;
clientHandle=newAsyncClientHandler(ip,port);
newThread(clientHandle,"Client").start();
}
//向服务器发送消息
publicstaticbooleansendMsg(Stringmsg)throwsException{
if(msg.equals("q"))returnfalse;
clientHandle.sendMsg(msg);
returntrue;
}
@SuppressWarnings("resource")
publicstaticvoidmain(String[]args)throwsException{
Client.start();
System.out.println("请输入请求消息:");
Scannerscanner=newScanner(System.in);
while(Client.sendMsg(scanner.nextLine()));
}
}

AsyncClientHandler:


packagecom.anxpp.io.calculator.aio.client;
importjava.io.IOException;
importjava.net.InetSocketAddress;
importjava.nio.ByteBuffer;
importjava.nio.channels.AsynchronousSocketChannel;
importjava.nio.channels.CompletionHandler;
importjava.util.concurrent.CountDownLatch;
publicclassAsyncClientHandlerimplementsCompletionHandler,Runnable{
privateAsynchronousSocketChannelclientChannel;
privateStringhost;
privateintport;
privateCountDownLatchlatch;
publicAsyncClientHandler(Stringhost,intport){
this.host=host;
this.port=port;
try{
//创建异步的客户端通道
clientChannel=AsynchronousSocketChannel.open();
}catch(IOExceptione){
e.printStackTrace();
}
}
@Override
publicvoidrun(){
//创建CountDownLatch等待
latch=newCountDownLatch(1);
//发起异步连接操作,回调参数就是这个类本身,如果连接成功会回调completed方法
clientChannel.connect(newInetSocketAddress(host,port),this,this);
try{
latch.await();
}catch(InterruptedExceptione1){
e1.printStackTrace();
}
try{
clientChannel.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
//连接服务器成功
//意味着TCP三次握手完成
@Override
publicvoidcompleted(Voidresult,AsyncClientHandlerattachment){
System.out.println("客户端成功连接到服务器...");
}
//连接服务器失败
@Override
publicvoidfailed(Throwableexc,AsyncClientHandlerattachment){
System.err.println("连接服务器失败...");
exc.printStackTrace();
try{
clientChannel.close();
latch.countDown();
}catch(IOExceptione){
e.printStackTrace();
}
}
//向服务器发送消息
publicvoidsendMsg(Stringmsg){
byte[]req=msg.getBytes();
ByteBufferwriteBuffer=ByteBuffer.allocate(req.length);
writeBuffer.put(req);
writeBuffer.flip();
//异步写
clientChannel.write(writeBuffer,writeBuffer,newWriteHandler(clientChannel,latch));
}
}

WriteHandler:


packagecom.anxpp.io.calculator.aio.client;
importjava.io.IOException;
importjava.nio.ByteBuffer;
importjava.nio.channels.AsynchronousSocketChannel;
importjava.nio.channels.CompletionHandler;
importjava.util.concurrent.CountDownLatch;
publicclassWriteHandlerimplementsCompletionHandler{
privateAsynchronousSocketChannelclientChannel;
privateCountDownLatchlatch;
publicWriteHandler(AsynchronousSocketChannelclientChannel,CountDownLatchlatch){
this.clientChannel=clientChannel;
this.latch=latch;
}
@Override
publicvoidcompleted(Integerresult,ByteBufferbuffer){
//完成全部数据的写入
if(buffer.hasRemaining()){
clientChannel.write(buffer,buffer,this);
}
else{
//读取数据
ByteBufferreadBuffer=ByteBuffer.allocate(1024);
clientChannel.read(readBuffer,readBuffer,newReadHandler(clientChannel,latch));
}
}
@Override
publicvoidfailed(Throwableexc,ByteBufferattachment){
System.err.println("数据发送失败...");
try{
clientChannel.close();
latch.countDown();
}catch(IOExceptione){
}
}
}

ReadHandler:


packagecom.anxpp.io.calculator.aio.client;
importjava.io.IOException;
importjava.io.UnsupportedEncodingException;
importjava.nio.ByteBuffer;
importjava.nio.channels.AsynchronousSocketChannel;
importjava.nio.channels.CompletionHandler;
importjava.util.concurrent.CountDownLatch;
publicclassReadHandlerimplementsCompletionHandler{
privateAsynchronousSocketChannelclientChannel;
privateCountDownLatchlatch;
publicReadHandler(AsynchronousSocketChannelclientChannel,CountDownLatchlatch){
this.clientChannel=clientChannel;
this.latch=latch;
}
@Override
publicvoidcompleted(Integerresult,ByteBufferbuffer){
buffer.flip();
byte[]bytes=newbyte[buffer.remaining()];
buffer.get(bytes);
Stringbody;
try{
body=newString(bytes,"UTF-8");
System.out.println("客户端收到结果:"+body);
}catch(UnsupportedEncodingExceptione){
e.printStackTrace();
}
}
@Override
publicvoidfailed(Throwableexc,ByteBufferattachment){
System.err.println("数据读取失败...");
try{
clientChannel.close();
latch.countDown();
}catch(IOExceptione){
}
}
}

这个API使用起来真的是很顺手。


4.3、测试

Test:


packagecom.anxpp.io.calculator.aio;
importjava.util.Scanner;
importcom.anxpp.io.calculator.aio.client.Client;
importcom.anxpp.io.calculator.aio.server.Server;
/**
*测试方法
*@authoryangtao__anxpp.com
*@version1.0
*/
publicclassTest{
//测试主方法
@SuppressWarnings("resource")
publicstaticvoidmain(String[]args)throwsException{
//运行服务器
Server.start();
//避免客户端先于服务器启动前执行代码
Thread.sleep(100);
//运行客户端
Client.start();
System.out.println("请输入请求消息:");
Scannerscanner=newScanner(System.in);
while(Client.sendMsg(scanner.nextLine()));
}
}

我们可以在控制台输入我们需要计算的算数字符串,服务器就会返回结果,当然,我们也可以运行大量的客户端,都是没有问题的,以为此处设计为单例客户端,所以也就没有演示大量客户端并发。


读者可以自己修改Client类,然后开辟大量线程,并使用构造方法创建很多的客户端测试。


下面是其中一次参数的输出:


服务器已启动,端口号:12345
请输入请求消息:
客户端成功连接到服务器...
连接的客户端数:1
123456+789+456
服务器收到消息: 123456+789+456
客户端收到结果:124701
9526*56
服务器收到消息: 9526*56
客户端收到结果:533456
...

AIO是真正的异步非阻塞的,所以,在面对超级大量的客户端,更能得心应手。


下面就比较一下,几种I/O编程的优缺点。


5、各种I/O的对比

先以一张表来直观的对比一下:


03


具体选择什么样的模型或者NIO框架,完全基于业务的实际应用场景和性能需求,如果客户端很少,服务器负荷不重,就没有必要选择开发起来相对不那么简单的NIO做服务端;相反,就应考虑使用NIO或者相关的框架了。


6、附录

上文中服务端使用到的用于计算的工具类:


package com.anxpp.utils;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public final class Calculator {
private final static ScriptEngine jse = new ScriptEngineManager().getEngineByName("JavaScript");
public static Object cal(String expression) throws ScriptException{
return jse.eval(expression);
}
}

更多文章:


Java NIO框架Netty简单使用


后续会写一篇NIO框架Netty的教程,不过这段时间有一点小忙。

最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台