netty和MIna他们是同一个架构开发的,封装了很多JDK的NIO.
1.我们为什么不直接使用jdk NIO?
API繁杂,使用非常麻烦.原始NIO可靠性比较低下,JDK的NIO存在epoll这个BUG,会导致Selector空轮询,官方说jdk1.6的update18版本已经修复,但是很多企业实践测试 还是存在这样的问题 ,只是触发概率降低.
2.netty可以运用在那些领域?
1分布式进程通信
例如: hadoop、dubbo、akka等具有分布式功能的框架,底层RPC通信都是基于netty实现的,这些框架使用的版本通常都还在用netty3.x
2、游戏服务器开发
最新的游戏服务器有部分公司可能已经开始采用netty4.x 或 netty5.x
案例:游戏玩家上线后的信息 缓存 下线后的清除
SimpleChannelHandler 处理消息接收和写
{
messageReceived接收消息
channelConnected新连接,通常用来检测IP是否是黑名单
channelDisconnected链接关闭,可以再用户断线的时候清楚用户的缓存数据等
}
Java1.4之前的早期版本,Java对I/O的支持并不完善,开发人员在开发高性能的I/O程序的时候,会面临着巨大的挑战和困难,主要问题如下:
1.没有数据缓冲区,I/O性能存在问题。NIO 结构增加数据缓冲区
2.没有C或者C++中的Channel(双高速管道 写入 读出 写入读出同时存在的业务)概念,只有输入和输出流。传统的IO管道 改善成Channel
3.线程模型方面:同步阻塞式I/O通信(BIO),通常会导致通信线程被长时间阻塞;
在Java至此异步I/O之前的很长一段时间里,高性能服务端的开发领域一直是被C++和C长期占据.
NIO:同步非阻塞
4.增加多路复用机制 Selector
阻塞IO模型:就好像去食堂排队打饭,只要前面的没完成,就会被阻塞,效率底下
非阻塞IO模型:IO任务执行到这点 ,如果这个点的数据或者其他的组件没有准备好的话,这个任务它不停留在这里,而是去执行其他的任务。
NIO编程,非阻塞式IO通信模型,采用Epoll多路复用机制
1.缓冲区buffer(增大IO吞吐性能)
2.高速通道Channel(业务包容性增大 减少频繁创建其他管道)
与流不同的是 双向
3.多路复用器Selector,用来不断的轮询注册到上面的多个Channel
SelectionKey 可以获取这些就绪通道的集合
Epoll()取代了传统的select实现,没有最大句柄的1024/2048的限制,
只需要一个线程负责Selector的轮询,就可以接入成千上万的客户端接入
4.NIO专用的服务类:ServerSocketChannel
ServerSocket io
ServerSocketChannel 服务类配合我们高速通道Channel
下面是一个demo
package wtz.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* Created by wtz on 2018/9/4.
*/
public class NIOServer {
private static ServerSocketChannel serverSocketChannel;
private static int port = 8080;
//信息写入
ByteBuffer rcBuffer = ByteBuffer.allocate(1024);
//信息写出
ByteBuffer sendBuffer = ByteBuffer.allocate(1024);
//多路复用器
private static Selector selector;
//维护一个实际上是一个事件标签的集合
Map<SelectionKey, String> sessionMsg = new HashMap<SelectionKey, String>();
//模仿Netty开辟线程池 jdk 四种类型
public NIOServer(int port) throws IOException {
this.port = port;
//打开通道
serverSocketChannel = ServerSocketChannel.open();
//绑定端口地址
serverSocketChannel.socket().bind(new InetSocketAddress(port));
//设置不阻塞
serverSocketChannel.configureBlocking(false);
//打开多路复用器
selector = Selector.open();
//通道注册多路复用器让其为通道工作
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("NIO服务已经启动,且监听端口是" + this.port);
}
//监听请求的方法模块
public void listener() throws IOException {
while (true) {
//进来就是通过selector来看有没有注册事件
int eventCount = selector.select();
if (eventCount <= 0) {
//继续轮询 NIO内部机制:不断的轮询注册到上面的多个Channel
continue;
}
//获取到就绪通道的集合
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
//处理客户端的事件
process(iterator.next());
//移除集合里面的事件
iterator.remove();
}
}
}
//详细的处理客户端事件
private void process(SelectionKey selectionKey) {
SocketChannel client = null;
try {
if (selectionKey.isValid() && selectionKey.isAcceptable()) {
client = serverSocketChannel.accept();
client.configureBlocking(false);
//告诉我们的复用器,下次可以读数据
client.register(selector, SelectionKey.OP_READ);
} else if (selectionKey.isValid() && selectionKey.isReadable()) {
//读到缓冲区
rcBuffer.clear();
client = (SocketChannel) selectionKey.channel();
int len = client.read(rcBuffer);
if (len > 0) {
System.out.println("服务端收到客户端的消息:" + new String(rcBuffer.array(), 0, len));
String msg = new String(rcBuffer.array(), 0, len);
sessionMsg.put(selectionKey, msg);
//告诉我们的复用器,下次可以写数据
client.register(selector, SelectionKey.OP_WRITE);
}
} else if (selectionKey.isValid() && selectionKey.isWritable()) {
if (!sessionMsg.containsKey(selectionKey)) {
return;
}
//服务器回客户端消息
client = (SocketChannel) selectionKey.channel();
sendBuffer.clear();
sendBuffer.put((new String(sessionMsg.get(selectionKey)) + ",你好,你的请求wtz已经处理").getBytes());
//这个实际上是设置读取位
sendBuffer.flip();
client.write(sendBuffer);
//告诉我们的复用器,下次可以读数据
client.register(selector, SelectionKey.OP_READ);
}
} catch (IOException e) {
//读取key的事件的时候,遇到客户端异常下线,不会引起异常
try {
selectionKey.cancel();
client.socket().close();
client.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
//简单的NIO消息通讯服务器
public static void main(String[] args) {
try {
new NIOServer(port).listener();
} catch (IOException e) {
e.printStackTrace();
}
}
}
package wtz.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
/**
* Created by wtz on 2018/9/4.
*/
public class NIOClient {
SocketChannel client;
InetSocketAddress serverAddress = new InetSocketAddress("localhost", 8080);
Selector selector;
ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);
ByteBuffer sendBuffer = ByteBuffer.allocate(1024);
public NIOClient() throws IOException {
client = SocketChannel.open();
client.configureBlocking(false);
client.connect(serverAddress);
selector = Selector.open();
client.register(selector, SelectionKey.OP_CONNECT);
}
public void session() throws IOException {
if (client.isConnectionPending()) {
client.finishConnect();
client.register(selector, SelectionKey.OP_WRITE);
System.out.println("已经连接到服务器,可以在控制台登记了");
}
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {
//键盘输入的内容
String name = scanner.nextLine();
if ("".equals((name))) {
continue;
}
if ("finish".equals(name)) {
System.exit(0);
}
process(name);
}
}
private void process(String name) throws IOException {
boolean waitHelp = true;
Iterator<SelectionKey> iterator = null;
Set<SelectionKey> keys = null;
while (waitHelp) {
try {
int readys = selector.select();
//如果没有客人,继续轮询
if (readys == 0) {
continue;
}
keys = selector.selectedKeys();
iterator = keys.iterator();
//一个一个key迭代检查
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
if (key.isValid() && key.isWritable()) {
//首先是判断是否可写,可写,就是代表客户端要对服务端发送信息
sendBuffer.clear();
sendBuffer.put(name.getBytes());
sendBuffer.flip();
client.write(sendBuffer);
client.register(selector, SelectionKey.OP_READ);
} else if (key.isValid() && key.isReadable()) {
//服务端发送信息回来给客户端,去读
receiveBuffer.clear();
int len = client.read(receiveBuffer);
if (len > 0) {
receiveBuffer.flip();
System.out.println("服务端反馈的消息:" + new String(receiveBuffer.array(), 0, len));
client.register(selector, SelectionKey.OP_WRITE);
waitHelp = false;
}
}
//检查完之后,打发客户走
iterator.remove();
}
} catch (IOException e) {
((SelectionKey) keys).cancel();
client.socket().close();
client.close();
return;
}
}
}
public static void main(String[] args) throws IOException {
new NIOClient().session();
}
}
以上就是关于NIO的一些记录