本篇博客分析Java中BIO NIO AIO和Netty模型
先来理解几个概念，同步与异步，阻塞与非阻塞
依然是烧水的例子，A去烧水，等待水开过程中A什么都不做，只等待，那就是阻塞；可以干别的，那就是非阻塞；水开之后，是否还是A来操作？依然是A操作，同步；换了B来操作，异步。
1.BIO Blocking-IO
BIO是阻塞的，它的阻塞体现在很多地方 例如下面的accept
public class BIOServer {
public static void main(String[] args) {
try {
ServerSocket ss = new ServerSocket();
ss.bind(new InetSocketAddress("127.0.0.1", 8000));
System.out.println("Socket Server has been established now at 127.0.0.1:8000");
while (true) {
// BIO 的accept是阻塞的，有socket连接过来，才会往下执行，没有就会阻塞在这
Socket accept = ss.accept();
// 建立连接之后 BIO的读写也是阻塞的，如果我前一个socket 在读写时阻塞，此刻server不接受其他的连接
// 我注释掉的单线程下io阻塞，整个server阻塞
//int len = socket.getInputStream().read(bytes);
// socket.getOutputStream().write(bytes, 0, len);
//socket.getOutputStream().flush();
/** 在这种模型下做了改造，把具体的io读写交给其他线程来执行，保证能够接受连接
* 这里我直接开启了新线程，之后可以改造成线程池来保护server不被吃满
/*
new Thread(() -> {
handle(accept);
}).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void handle(Socket socket) {
byte[] bytes = new byte[1024];
try {
int len = socket.getInputStream().read(bytes);
socket.getOutputStream().write(bytes, 0, len);
socket.getOutputStream().flush();
} catch (IOException e) {
e.printStackTrace();
try {
socket.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}BIO可以理解成基于线程驱动的模型，BIO本身就是阻塞的，但是可以通过线程和线程池来优化，BIO的读写是byte[]
2 . NIO Non-Blocking IO
NIO是一种非阻塞的IO，他在处理socket连接和io读写采用的是轮询，最外层的线程加了slector选择器，通过不断的轮询被选择的key，来完成建立连接和读写
上代码
public class NIOServer {
public static void main(String[] args) {
try {
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(new InetSocketAddress("127.0.0.1", 8000));
// 这里设置非阻塞
ssc.configureBlocking(false);
System.out.println("Socket server in single pool mode started,listening on:" + ssc.getLocalAddress());
// 开启选择器
Selector selector = Selector.open();
// 给选择器注册OP_ACCEPT，用来选择建立请求的操作
ssc.register(selector, SelectionKey.OP_ACCEPT);
// while循环
while (true) {
selector.select(); //select这里是阻塞的，while不会一直执行，当有OP请求时，才会执行
// 获取所有的操作KEY
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> iterator = keys.iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
// 移除key，防止重复消费
iterator.remove();
// 操作处理逻辑
handle(key);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void handle(SelectionKey key) {
if (key.isAcceptable()) {
// 判断key是accept，注册一个read key
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
try {
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);
sc.register(key.selector(), SelectionKey.OP_READ);
} catch (IOException e) {
e.printStackTrace();
}
} else if (key.isReadable()) {
// 判断时IO的写操作，执行写的处理逻辑
SocketChannel sc = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.clear();
try {
int len = sc.read(buffer);
String content = len != -1 ? new String(buffer.array(), 0, len) : "";
ByteBuffer writeBuffer = ByteBuffer.wrap(("Response from server:" + content).getBytes());
sc.write(writeBuffer);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (sc != null) {
try {
sc.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}上面是单线程模式下的NIO，一个selector不仅要管理连接的建立，还要管理IO的读写操作，压力很大，于是我把它改成了多线程来处理读写，主线程只管建立连接
private void handle(SelectionKey key) throws IOException {
if (key.isAcceptable()) {
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
// IO读写给到Threadhandle的run()去做
threadPool.execute(new Threadhandle(key));
}
}
NIO跟BIO不同，他是非阻塞的，同时他的IO读写是通过ByteBuffer来处理的
3. AIO Asynchronous-IO
AIO 是异步非阻塞的，他是采用事件响应来实现异步，可以理解成回调函数，钩子，触发器句柄
public class AIOServer {
public static void main(String[] args) throws IOException {
AsynchronousServerSocketChannel assc = AsynchronousServerSocketChannel.open().bind(
new InetSocketAddress("127.0.0.1", 8000));
// 跟NIO的while(true)不同，AIO不会一直去遍历，他会把accept的操作挂在处理器类上，重写里面的completed方法
//和failed方法
assc.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
@Override
public void completed(AsynchronousSocketChannel client, Object attachment) {
// 建立连接成功之后的回调函数
assc.accept(null, this);
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 给read操作绑定回调函数
client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
attachment.flip();
String response = new String(attachment.array(), 0, result);
client.write(ByteBuffer.wrap(response.getBytes()));
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
exc.printStackTrace();
}
});
}
@Override
public void failed(Throwable exc, Object attachment) {
exc.printStackTrace();
}
});
}
}
当然AIO也有多线程的模型，用起来也很方便，初始化的时候传一个线程池
ExecutorService executorService = Executors.newCachedThreadPool();
AsynchronousChannelGroup threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);
AsynchronousServerSocketChannel assc = AsynchronousServerSocketChannel.open(threadGroup).bind(
new InetSocketAddress("127.0.0.1", 8000));我理解的AIO，很好的诠释了Reactor，我整个过程都是异步的，我把请求要执行的函数地址告诉OS，让OS遇到请求时，通过函数地址去执行方法，AIO的IO读写依然是ByteBuffer
4. Netty
下面说最火的Netty 是如何做的
Netty在现在主流的服务器用来做机器通信，tomcat apache，rpc框架也用；Netty实际上跟AIO很类似，但更友好；他封装的是NIO，而不是AIO，因为NIO和AIO的底层都是使用的epoll模型（这个之后博客我打算分享给大家），对应linux底层的IO模型都是轮询，而AIO本身就是对NIO的封装，考虑到这些，Netty在NIO的基础上封装
public class NettyServer {
private int port = 8000;
public NettyServer(int port) {
this.port = port;
}
public void serverStart() {
// Netty封装NIO，把之前的Selector也变成了线程池操作，可以理解成处理连接的线程池
NioEventLoopGroup mastser = new NioEventLoopGroup();
// 处理IO读写操作线程池
NioEventLoopGroup worker = new NioEventLoopGroup();
// 配置启动项
ServerBootstrap bootstrap = new ServerBootstrap();
// 填充启动参数 配置master和worker，channel类型，初始化的执行类
bootstrap.group(mastser, worker).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {
@Override
// 重写初始化channel方法
protected void initChannel(SocketChannel ch) throws Exception {
// 给通道加处理类
ch.pipeline().addLast(new Handler());
}
});
try {
// 注意，Netty的 建立连接和IO读写都是异步，不理解的可以看看ChannelFuture 类，这里不展开说明
ChannelFuture future = bootstrap.bind(port).sync();
future.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
mastser.shutdownGracefully();
worker.shutdownGracefully();
}
}
// 这个类是请求的处理类
class Handler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// 这里Netty封装的很好，给了一个context，给了一个object的 msg，可以直接对这两个参数操作，来处理读写
System.out.println("read action");
ByteBuf buf = (ByteBuf) msg;
System.out.println(buf.toString());
ctx.writeAndFlush("success received");
ctx.close();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
// super.exceptionCaught(ctx, cause);
cause.printStackTrace();
ctx.close();
}
}
public static void main(String[] args) {
NettyServer server = new NettyServer(8000);
server.serverStart();
}
}Netty 是异步非阻塞的，响应式的处理，他会给每一个操作挂载具体的方法实现，在接收到请求时，自动执行，我认为的Netty收到欢迎很大是因为他的代码书写特别清晰，每一步的目的很强，还有Netty不用ByteBuffer了，不用被flip()支配了，下面挂一个netty的client调用的代码
public class NettyClient {
public static void main(String[] args) {
new NettyClient().clientStart();
}
public void clientStart() {
NioEventLoopGroup worker = new NioEventLoopGroup();
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(worker)
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
System.out.println("channel established");
ch.pipeline().addLast(new ClienHandler());
}
});
}
class ClienHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ChannelFuture future = ctx.writeAndFlush(Unpooled.copiedBuffer("message".getBytes()));
future.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
System.out.println("send messages succeed");
}
});
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
try {
ByteBuf message = (ByteBuf) msg;
System.out.println(message);
} finally {
ReferenceCountUtil.release(msg);
}
}
}
}
配置之类的和server类似，但他只需要worker就可以；有趣的是，他给pipline 添加的处理类ChannelInboundHandlerAdapter 中，有个channel建立后的处理，里面有个future.addListener，定义了操作完成后的回调，设计的真好！
本篇介绍到这，本来想画几个模型图，以后再说吧
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
