C10破局(三)——Java AIO实现高并发服务器

上一篇博客中我们介绍了Java中的NIO模型,而JDK1.7之后升级NIO类库,也就是NIO2.0.Java正式提供了异步IO操作,同时提供了与UNIX网络编程事件驱动IO相对应的AIO。NIO(non-block IO)指的是同步非阻塞IO,AIO(Asynchronous IO)则是异步非阻塞IO。我们先来了解一些基础知识,最后再用AIO来设计一个服务器。

一、IO处理模型

C10破局(三)——Java AIO实现高并发服务器_第1张图片

服务器往客户端发送数据的过程主要有以下四步:

1、服务器调用read()方法,由用户态转为内核态,把磁盘的数据读到Read Buffer(内核缓存区)上;

2、read()方法返回,把Read Buffer(内核缓存区)的数据读到Buffer上,服务器由内核态转为用户态;之后对Buffer中的数据做进一步处理;

3、数据处理完之后,服务器调用send()方法,由用户态转为内核态,把Buffer中的数据读到Socket Buffer上;

4、将数据读到NIC Buffer(NetWork Interface Card,网卡的缓存区),send()方法返回,服务器由内核态转为用户态;

如果想更详细地了解IO的知识,可以看下这篇博文(https://www.jianshu.com/p/9b2922c10129)

二、NIO和AIO的区别

1、同步与异步

NIO,又称同步IO,当应用程序发出一个IO请求后,它需要主动去检查这个IO请求是否完成。

AIO,又称异步IO,当应用程序发出一个IO请求后,就不再管它了,当这个IO请求完成之后,操作系统主动通知应用程序来做后续的处理。

举个例子:你在家里烧开水,你把水放进去烧以后就去看电视了。如果是普通的烧水壶,你每隔一段时间都要去看一眼水烧开了没有,这就是同步IO;但是如果是响水壶,你只要安安静静地看你的电视,等水壶一响,你就知道水烧开了,这就是异步IO。

2、设计模式

NIO采用Reactor的设计模式,而AIO采用Proactor的设计模式。

Reactor和Proactor最主要的区别就是数据的读取和写入Buffer的操作由谁来完成。

对于Reactor而言,它被激活时仅表示当前SocketChannel中有数据来了,应用程序需要自己把SocketChannel中的数据搬到Buffer里面;

而Proactor被激活时则表示SocketChannel中有数据来了,并且我已经帮你把它搬到Buffer里面了,应用程序可以直接对Buffer中的数据进行处理。

3、适用场景

NIO采用了Reactor的模式,读写由应用程序自己进行,适合用于连接数目多且连接短的场景中

AIO采用了Proactor,读写操作由内核完成,适合用于连接数目多且连接长的场景中

三、AIO原理

1、Java回调模式

设想这么一个场景,我们现在需要往磁盘中取数据进行处理,并把处理后的结果发送给客户端。

(1)、传统方法

定义一个类A,实现read()、process()和send()三个方法,在线程中一次调用这三个方法。但是计算很复杂,主线程就会一直阻塞在process()方法中。

C10破局(三)——Java AIO实现高并发服务器_第2张图片

(2)、异步调用

我们定义了两个类,其中类A包含read()和send()方法,类B包含process()方法。首先我们启动主线程读取数据,数据读取结束后我们就启动新线程实例化类B,调用它的process()处理数据,主线程就可以做其他事了。等到b.process()方法执行结束后,再主动回调a的send()方法即可。

C10破局(三)——Java AIO实现高并发服务器_第3张图片

关于Java回调模式,奉上一篇通俗易懂的博文(《java回调函数详解》)

2、AIO原理图

C10破局(三)——Java AIO实现高并发服务器_第4张图片

我们根据上面的原理来分析一下AIO的过程

(1)、客户端

A、首先建立一个AsynchronusSocketChannel,绑定端口号,并调用它的connect()方法尝试连接服务器,并指明connect()方法的回调类为ConnectCompletionHandler;

B、连接服务器得到两种返回值。如果连接失败则调用AcceptCompletionHandler类的failed()方法进行后续处理,如果成功,则调用ConnectCompletionHandler类的completion()方法进行后续处理。

(2)、服务端

A、建立一个AsynchronousServerSocketChannel,绑定端口号,调用accept()方法等待客户端连接,并指明accept()方法的回调类为AcceptCompletionHandler;

B、判断连接是否成功,如果失败就调用AcceptCompletionHandler的failed()方法,如果成功就调用AcceptCompletionHandler的completed()方法;

C、如果调用了AcceptCompletionHandler的completed()方法,即连接成功时。服务端总共进行了三个操作。一个是建立AsynchronousSocketChannel与当前的客户端建立连接(调用completed()方法之前),一个是调用AsynchronousServerSocketChannel.accept()继续处理其他的客户端连接(调用completed()方法时),最后一个是调用AsychronousSocketChannel.read()进行客户端消息的读操作,并指明回调类为ReadCompletionHandler

D、如果AsynchronousSocketChannel接收到数据,在接收完数据后,会调用ReadCompletionHandler.completed()方法对消息进行处理

(3)注意点

A、所有方法的回调结果都由相应的CompletionHandler类的进行处理,eg.accept()方法由AcceptCompletionHandler类(实现了CompletionHandler接口的类)进行处理。

四、代码实现

1、服务器

(1)、TimeServer类

package aioserver;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class TimeServer {

	public static void main(String[] args) throws IOException {
		int port = 8080;
		if (args != null && args.length > 0) { 
			try{
				port = Integer.valueOf(args[0]);
			}catch(NumberFormatException e){
				
			}
		}
		
		/*
		 *创建异步的时间服务器处理类,并启动线程将其拉起
		 */
		AsyncTimeServerHandler timeServer = new AsyncTimeServerHandler(port);
		
		new Thread(timeServer,"AIO-AsyncTimeServerHandler-001").start();
	}
}

(2)、AsyncTimeServerHandler类

package aioserver;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.CountDownLatch;

public class AsyncTimeServerHandler implements Runnable{
	private int port;
	/*
	 * CountDownLatch类位于java.util.concurrent包下,
	 * 利用它可以实现类似计数器的功能。比如有一个任务A,
	 * 它要等待其他4个任务执行完毕之后才能执行,
	 * 此时就可以利用CountDownLatch来实现这种功能了。
	 */
	CountDownLatch latch;
	AsynchronousServerSocketChannel asychronousServerSocketChannel;
	
	public AsyncTimeServerHandler(int port) {
		this.port = port;
		try {
			//1、创建一个异步的服务器通道AsynchronousServerSocketChannel,并绑定端口号
			asychronousServerSocketChannel = AsynchronousServerSocketChannel.open();
			asychronousServerSocketChannel.bind(new InetSocketAddress(port));
			System.out.println("The time server is start in port : " + port);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

	public void run() {
		//初始化CountDownLantch为1,在完成一组正在执行的操作之前,允许当前线程一直阻塞
		//这里是为了防止服务端执行完成退出
		//在实际的项目应用中,不需要启动独立的线程来处理AsynchronousServerSocketChannel?
		latch = new CountDownLatch(1);
		
		doAccept();
		//等待线程执行完毕
		try {
			//await()和wait()的区别
			latch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void doAccept() {
		//1、调用accept()方法,并指明回调类为AcceptCompletionHandler,不过这里用了匿名内部类,没有定义出具体的类名
		asychronousServerSocketChannel.accept(this, new CompletionHandler() {
			//2、判断是否连接成功,成功就调用completed()方法
            @Override
            public void completed(AsynchronousSocketChannel result,
                                  AsyncTimeServerHandler attachment) {
            	//3、调用accept()方法,监听其他的客户端连接
                attachment.asychronousServerSocketChannel.accept(attachment, this);
                //链路建立成功之后,服务端需要接收客户端的请求消息,
                //创建新的ByteBuffer,预分配1M的缓冲区。
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                //3、调用AsynchronousSocketChannel的read方法进行异步读操作,并指明回调类为ReadCompletionHandler
                result.read(buffer, buffer, new ReadCompletionHandler(result));
            }

            @Override
            public void failed(Throwable exc, AsyncTimeServerHandler attachment) {
                exc.printStackTrace();
                attachment.latch.countDown();
            }
        });
        
	}
	

}

(3)、ReadCompletionHandler类

package aioserver;

import java.nio.ByteBuffer;
import java.nio.channels.CompletionHandler;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.channels.AsynchronousSocketChannel;

public class ReadCompletionHandler implements CompletionHandler {
    private AsynchronousSocketChannel channel;

    public ReadCompletionHandler(AsynchronousSocketChannel channel) {
        //将AsynchronousSocketChannel通过参数传递到ReadCompletion Handler中当作成员变量来使用
        //主要用于读取半包消息和发送应答。本例程不对半包读写进行具体说明
        if (this.channel == null)
            this.channel = channel;
    }

    //4、读取消息结束,调用ReadCompletionHandler.completed()方法进行处理
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        //读取到消息后的处理,首先对attachment进行flip操作,为后续从缓冲区读取数据做准备。
        attachment.flip();
        //根据缓冲区的可读字节数创建byte数组
        byte[] body = new byte[attachment.remaining()];
        attachment.get(body);
        try {
            //通过new String方法创建请求消息,对请求消息进行判断,
            //如果是"QUERY TIME ORDER"则获取当前系统服务器的时间,
            String req = new String(body, "UTF-8");
            System.out.println("The time server receive order : " + req);
            String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(req) ? new java.util.Date(
                    System.currentTimeMillis()).toString() : "BAD ORDER";
            //调用doWrite方法发送给客户端。
            doWrite(currentTime);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    private void doWrite(String currentTime) {
        if (currentTime != null && currentTime.trim().length() > 0) {
            //首先对当前时间进行合法性校验,如果合法,调用字符串的解码方法将应答消息编码成字节数组,
            //然后将它复制到发送缓冲区writeBuffer中,
            byte[] bytes = (currentTime).getBytes();
            ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
            writeBuffer.put(bytes);
            writeBuffer.flip();
            //最后调用AsynchronousSocketChannel的异步write方法。
            //正如前面介绍的异步read方法一样,它也有三个与read方法相同的参数,
            //在本例程中我们直接实现write方法的异步回调接口CompletionHandler。
            channel.write(writeBuffer, writeBuffer,
                    new CompletionHandler() {
                        @Override
                        public void completed(Integer result, ByteBuffer buffer) {
                            //对发送的writeBuffer进行判断,如果还有剩余的字节可写,说明没有发送完成,需要继续发送,直到发送成功。
                            if (buffer.hasRemaining())
                                channel.write(buffer, buffer, this);
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            //关注下failed方法,它的实现很简单,就是当发生异常的时候,对异常Throwable进行判断,
                            //如果是I/O异常,就关闭链路,释放资源,
                            //如果是其他异常,按照业务自己的逻辑进行处理,如果没有发送完成,继续发送.
                            //本例程作为简单demo,没有对异常进行分类判断,只要发生了读写异常,就关闭链路,释放资源。
                            try {
                                channel.close();
                            } catch (IOException e) {
                                // ingnore on close
                            }
                        }
                    });
        }
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        try {
            this.channel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

说明:本文代码部分主要来自《netty权威指南一书》

C10k系列文章:

《C10k破局(一)——线程池和消息队列实现高并发服务器》

《C10k破局(二)——Java NIO实现高并发服务器(一张图看懂Java NIO)》

《C10破局(三)——Java AIO实现高并发服务器》

你可能感兴趣的:(高性能服务器)