概述
从同步与异步&阻塞与非阻塞的概念,到具体的I/O模型,再到具体的Java语言实现,都是层层递进,本篇就从Java语言来看I/O模型的大概情况。
整个Java I/O模型,大致可以分为三类
- BIO:JDK1.4之前的阻塞IO
- NIO:JDK1.4及以后的版本非阻塞IO
- AIO:JDK1.7之后,又叫NIO.2
一、BIO阻塞IO
1、基本概念
BIO,即为Blocking I/O,阻塞IO,大致流程为:
- 1、服务端建立ServerSocket,以一个端口启动
- 2、等待客户端建立socket连接,如果没有连接,一直阻塞
- 3、一个socket建立连接之后,从线程池中去一个线程取处理socket
2、代码分析
public class BlockingIOServer {
public static void main(String[] args) throws IOException {
int port = 10000;
ExecutorService threadPool = Executors.newFixedThreadPool(10);
ServerSocket server = new ServerSocket(port);
while(true){
Socket client = server.accept();
//从线程池取线程处理client
threadPool.execute(()->{
try{
InputStream input = client.getInputStream();
//TODO read input
String req = null;
String res = "response:"+req;
//TODO response
client.getOutputStream().write(res.getBytes());
}catch(IOException e){
e.printStackTrace();
}finally {
try {
client.close();
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
}
}
3、总结
- 如果请求量过大,线程池不够用,那么会严重影响性能。CPU疲于切换线程,执行的效率降低。
-
现在tomcat I/O模型默认还是BIO。
-
但是连接不大,该模型还是非常具有优越性,代码编写简单,只需要关注该线程内的连接即可。
-
BIO模型,也就是同步非阻塞模型。
二、NIO非阻塞IO
1、基本概念
-
NIO,即是Non Blocking I/O,非阻塞IO。
-
在JDK1.4及以后版本中提供了一套API来专门操作非阻塞I/O,接口以及类定义在java.nio包。由于这套API是JDK新提供的I/O API,因此,也叫New I/O。
- NIO API由四个主要的部分组成:缓冲区(Buffers)、通道(Channels)、选择器(Selector)和非阻塞I/O的核心类组成。
NIO 的工作大致流程为:
- 1、通道注册一个监听到事件处理器
- 2、有事件发生时,事件处理器会通知相应的通道处理
2、代码分析
public class NonBlockingIOServer {
private int BLOCK = 4096;
private ByteBuffer sendBuffer = ByteBuffer.allocate(BLOCK);
private ByteBuffer receiveBuffer = ByteBuffer.allocate(BLOCK);
private Selector selector;
public NonBlockingIOServer(int port) throws IOException {
//1.open ServerSocketChannel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//2.configureBlocking false
serverSocketChannel.configureBlocking(false);
//3.bind port
serverSocketChannel.socket().bind(new InetSocketAddress(port));
//4.open Selector
selector = Selector.open();
//5.serverSocketChannel register select
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Server Start,port:"+port);
}
private void accept() throws IOException {
while (true) {
// 1.select,block
selector.select();
// 2.SelectionKey iterator
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while (iterator.hasNext()) {
SelectionKey selectionKey = iterator.next();
iterator.remove();
try {
doAccept(selectionKey);
} catch (IOException e) {
selectionKey.cancel();
e.printStackTrace();
}
}
}
}
private void doAccept(SelectionKey selectionKey)throws IOException{
if (selectionKey.isAcceptable()) {
// ServerSocketChannel 的 selectionKey
ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel();
if(null == server){
return;
}
//接受到此通道套接字的连接,block here
SocketChannel client = server.accept();
// 配置为非阻塞
client.configureBlocking(false);
// 注册读到selector,等待读的selectionKey
client.register(selector, SelectionKey.OP_READ);
} else if (selectionKey.isReadable()) {
// SocketChannel 的 selectionKey
SocketChannel client = (SocketChannel) selectionKey.channel();
receiveBuffer.clear();
int count = client.read(receiveBuffer);
if (count > 0) {
String receiveText = new String( receiveBuffer.array(),0,count);
System.out.println(receiveText);
//注册写到selector,等待读的selectionKey
SelectionKey key = client.register(selector, SelectionKey.OP_WRITE);
//这里可以作为设计框架的扩展之处
key.attach(receiveText);
}
} else if (selectionKey.isWritable()) {
// SocketChannel selectionKey
SocketChannel client = (SocketChannel) selectionKey.channel();
//取出read 的 attachment
String request = (String) selectionKey.attachment();
String sendText="response--" + request;
sendBuffer.clear();
sendBuffer.put(sendText.getBytes());
sendBuffer.flip();
//输出到通道
client.write(sendBuffer);
System.out.println(sendText);
client.register(selector, SelectionKey.OP_READ);
}
}
/** * [[@param](http://my.oschina.net/u/2303379)](http://my.oschina.net/u/2303379) args * [[@throws](http://my.oschina.net/throws)](http://my.oschina.net/throws) IOException */
public static void main(String[] args) throws IOException {
int port = 10000;
NonBlockingIOServer server = new NonBlockingIOServer(port);
server.accept();
}
}
主要流程为:
- 1、open ServerSocketChannel,configureBlocking false,bind host and port
- 2、open Selector
- 3、ServerSocketChannel register on Selector
- 4、有客户端连接的事件发生,事件处理器通知ServerSocketChannel去处理
3、总结
- NIO本身是基于事件驱动思想来完成的,即是Reactor模式。
- 在使用传统同步I/O模型如果要同时处理多个客户端请求,就必须使用多线程来处理。也就是说,将每一个客户端请求分配给一个线程来单独处理。这样可以达到我们的要求,但是如果客户端的请求过多,服务端程序可能会因为不堪重负而拒绝客户端的请求,甚至服务器可能会因此而瘫痪。
-
而NIO基于Selector,当有感兴趣的事件发生时,就通知对应的事件处理器去处理事件,如果没有,则不处理。当socket有流可读或可写入socket时,操作系统会相应的通知引用程序进行处理,应用再将流读取到缓冲区或写入操作系统。所以使用一个线程做轮询就可以了。
-
Buffer,也是NIO的一个新特性,可以块状的读/写数据,效率得到极大的提高。
-
所以NIO提高了线程的利用率,减少系统在管理线程和线程上下文切换的开销。
三、AIO异步非阻塞IO
1、基本概念
- AIO,即是Asynchronous I/O,异步非阻塞I/O
- JDK1.7之后,引入NIO.2,也叫作AIO,工作方式是异步非阻塞
AIO主要工作流程为:
- 客户端发起一个IO调用
- 服务端接受IO之后,异步回调接收成功后的IO,不会阻挡当前主流程,主流程继续接受下一个请求
2、代码分析
public class AsynchronousIOServer {
private static Charset charset = Charset.forName("UTF-8");
public static void main(String[] args) {
int port = 10000;
int processors = Runtime.getRuntime().availableProcessors();
ExecutorService threadPool = Executors.newFixedThreadPool(processors);
try {
AsynchronousChannelGroup group = AsynchronousChannelGroup.withThreadPool(threadPool);
AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group);
server.bind(new InetSocketAddress(port));
doAccept(server);
group.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
System.out.println("close server");
System.exit(0);
}
}
private static void doAccept(AsynchronousServerSocketChannel server) {
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
@Override public void completed(AsynchronousSocketChannel client, Void attachment) {
server.accept(null, this);// accept next client connect
doRead(client, attachment);
}
@Override public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
}
private static void doRead(AsynchronousSocketChannel client, Void attachment) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override public void completed(Integer result, ByteBuffer attachment) {
if (result <= 0) {
try {
System.out.println("客户端断线:" + client.getRemoteAddress().toString());
attachment = null;
} catch (IOException e) {
e.printStackTrace();
}
return;
}
attachment.flip();
String req = charset.decode(attachment).toString();
attachment.compact();
client.read(attachment, attachment, this);// next client read
/** do service code **/
System.out.println(req);
ByteBuffer resBuffer = ByteBuffer.wrap(("response:" + req).getBytes());
doWrite(client, resBuffer, resBuffer);
}
@Override public void failed(Throwable exc, ByteBuffer attachment) {
exc.printStackTrace();
}
});
}
private static <V> void doWrite(AsynchronousSocketChannel client, ByteBuffer resBuffer, ByteBuffer attachment) {
client.write(attachment, attachment, new CompletionHandler<Integer, ByteBuffer>() {
@Override public void completed(Integer result, ByteBuffer attachment) {
// TODO write success
if (result <= 0) {
try {
System.out.println("客户端断线:" + client.getRemoteAddress().toString());
attachment = null;
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Override public void failed(Throwable exc, ByteBuffer attachment) {
exc.printStackTrace();
}
});
}
}
主要流程为:
- 1、创建一个异步非阻塞服务端
- 2、服务端接受一个请求,异步回调接受成功后的IO请求,然后继续接受下一个请求
- 3、异步回调请求的IO,读取请求数据成功后,异步回调读取后的结果,然后继续读下面的数据,不会阻塞当前IO读
- 4、异步回调的读IO数据,然后同步处理数据,这里可能是计算逻辑,所以这里也是性能的瓶颈之处,如果是计算密集型,AIO模型不适用,处理完成之后,异步写数据到IO请求
3、总结
- 与NIO不同,NIO每次都是事件通知,代码处理时异常复杂,而AIO当进行读写操作时,只须直接调用API的read或write方法即可。这两种方法均为异步的
- 对于读操作而言,当有流可读取时,操作系统会将可读的流传入read方法的缓冲区,并异步回调通知应用程序;
- 对于写操作而言,当操作系统将write方法传递的流写入完毕时,操作系统主动通知应用程序。
- 在JDK1.7中,这部分内容被称作NIO.2
- select/poll/epoll/iocp。在Linux 2.6以后,java NIO的实现,是通过epoll来实现的,这点可以通过jdk的源代码发现。
- 而AIO,在windows上是通过IOCP实现的,在linux上还是通过epoll来实现的。
- 这里强调一点:AIO,这是I/O处理模式,而epoll等都是实现AIO的一种编程模型;换句话说,AIO是一种接口标准,各家操作系统可以实现也可以不实现。在不同操作系统上在高并发情况下最好都采用操作系统推荐的方式。Linux上还没有真正实现网络方式的AIO。
四、大总结
1、文中所用代码
全在这里
2、三种I/O模型适用场景
-
BIO方式适用于连接数量小,连接时间短,计算密集,代码编写直观,程序直观简单易理解,JDK1.4之前。
-
NIO方式适用于连接数量大,连接时间短,比如Http服务器,并发局限于应用中,编程比较复杂,JDK1.4开始支持。
-
AIO方式使用于连接数量大,连接时间长,IO密集型,比如聊天服务器,充分调用OS参与并发操作,编程比较复杂,JDK7开始支持。
另外要清楚理解的:
- I/O属于底层操作,需要操作系统支持,并发也需要操作系统的支持,所以性能方面不同操作系统差异会比较明显。
- AIO是操作系统准备好数据之后通知应用程序,而NIO是程序不断的轮询操作系统是否有准备好数据。
五、文章引用
- NIO详解
- java aio 编程
- Java IO: BIO, NIO, AIO
- JAVA中IO技术:BIO、NIO、AIO