netty
什么是netty？
Netty是JBoss提供的一个java开源框架，是基于NIO（Non-Blocking IO）的客户端/服务器编程框架，既能快速开发高并发、高可用、高可靠的服务器程序，也可以开发靠并发、高可靠的客户端程序。
Netty提供了异步的、事件驱动的网络应用程序框架和工具，作为一个异步框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的获取或者通过通知机制获得IO操作结果。
Netty的优点：
1、API使用简单、门槛低。
2、功能强大、预置了多种编解码功能，支持多种主流协议。
3、定制能力强、可以通过channel handler对通信框架进行灵活扩展。
4、性能高、社区活跃、产品成熟。
高并发IO的底层原理
-
IO读写的基本原理
操作系统将内存分为两部分、一部分是内核空间，一部分是用户空间。用户没有权限访问内核空间，只有通过系统调用向内核发出指令才可以进行调用系统资源等操作。用户程序进行IO读写时依赖于底层的IO读写的，底层的read和write两大系统将内核缓冲区的数据读到应用程序的缓冲区，或者将应用程序缓冲区的数据读到内核缓冲区。
缓冲区的设置是为了减少计算机与设备之间频繁的物理交换，外部设备的直接读写涉及到操作系统的中断，而中断的恢复是要恢复之前的保存的数据和状态的，频繁的系统中断会造成时间和性能的损耗。 -
四种主要的IO模型
1、BIO（同步阻塞IO）
阻塞IO指的是只有当内核IO操作彻底完成后才会返回用户空间执行用户程序的操作指令，也就是说这段时间内用户进程处于阻塞状态。传统的IO模型都是阻塞IO。
优点：应用开发简单，在阻塞等待数据期间，用户进程被挂起，基本不会占用Cpu资源。
缺点：在高并发的环境中，需要为每一个线程维护一个连接的IO操作，开销巨大。
2、NIO（同步非阻塞IO）
用户向内核请求数据，如果内核的数据没有准备好，则会返回一个状态而不是阻塞用户线程，用户线程可以继续执行其他的操作，用户线程轮询发起系统调用，当内核数据准备好后才会加入阻塞状态将内核缓冲区数据复制到用户缓冲区。
缺点：当一个线程要进行多次读操作时，且读操作所需的数据都未准备好，那么用户线程就会频繁的发起read请求，而read请求是系统调用，带来大量的上下文切换（因为系统调用会在内核态和用户态之间转换）。
3、IO多路复用
操作系统引入一种新的系统调用，专门用于查询IO文件描述符的状态（含套接字），
Linux中引入的时select和epoll，该系统调用使得一个用户进程可以监视多个文件描述符，一旦描述符的状态就绪，就将文件描述符的状态发送给用户线程，用户进行系统调用。
4、异步IO（AIO)
NIO的三大组件
java中的NIO 其实是IO多路复用。-
java中NIO的三大组件分别为buffer、channel、selector。NIO是面向缓冲区的，每次通过管道从内存读取数据到缓冲区，再从缓冲区读取数据到管道发送至用户。
Buffer类常用属性和方法
- buffer初始状态为写状态，通过allocate方法初始化大小。
初始化后，capacity为容量，limit=capacity，position=0；此时写入n个数据 - 使用flip方法后变为读状态，limit=n，position=0。读取a个数据（a<=n）。此时position==a。
- 使用mark方法标记位置，再读取b个数据(a+b<=n)。此时position==a+b。
- 使用reset方法position变为a，也就是之前标记位置。
- 使用rewind方法position变为0。
- 使用clear，变为写状态，position=0，limit=capacity=n。
- 写入m个新数据，此时前m个为新数据，后n-m个为旧数据
- 使用flip方法，position=0，limit=m，注意此时m！=n，m只会变为前一次写状态写入的数据的个数，而不是这个buffer所拥有的全部数据的个数。此时读状态只能读新数据，而读不了后面n-m个旧数据。
public static void BufferDemo(){
//初始化一个缓冲区，分配大小为20
IntBuffer buffer = IntBuffer.allocate(20);
//当前缓冲区的状态为写状态，position为0，limit（可以加入的数据的量）为20，capacity（容量）为20
System.out.println("position: "+buffer.position());//0
System.out.println("limit: "+buffer.limit());//20
System.out.println("capacity: "+buffer.capacity());//20
//写入10个数字
for (int i = 0; i < 10; i++) {
buffer.put(i);
}
System.out.println("after writing 10 nums, position: "+buffer.position());//10
//从写状态转换状态为读状态，此时position为0，limit为写入的数据量
buffer.flip();
System.out.println("position: "+buffer.position());//0
System.out.println("limit: "+buffer.limit());//10
//读三个数字之后
for (int i = 0; i < 3; i++) {
System.out.println(buffer.get());
}
System.out.println("after read 3 nums, position: "+buffer.position());//3
//倒带，将position变为0，可以重新读取数据
buffer.rewind();
System.out.println("after rewind, position: "+buffer.position());//0
for (int i = 0; i < 4; i++){
buffer.get();
}
//存储一个临时位置，通常和reset一起使用
buffer.mark();
for (int i = 0; i < 3; i++){
buffer.get();
}
//让位置变为之前存储的位置，也就是4，而不是7
buffer.reset();
System.out.println("after reset, position: "+buffer.position());//4
//清空buffer，position变为0，limit变为最大容量
buffer.clear();
}
Channel类常用属性和方法
Java中重要的channel实现有FileChannel、SocketChannel、ServerSocketChannel、DatagramChannel。
FileChannel：用于文件数据的读写。
SocketChannel：用于套接字TCP连接的读写
ServerSocketChannel：服务器套接字通道，允许我们监听TCP连接请求，为每一个监听到的请求创建一个SocketChannel通道。
DatagramChannel：数据报通道，用于UDP数据的读写。
Selector
基于socketChannel和selector实现客户端和服务端通信
客户端代码：
public class SocketClient {
public static void main(String[] args) throws IOException {
sendMsg();
}
public static void sendMsg() throws IOException {
SocketChannel socketChannel =SocketChannel.open();
boolean connect = socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
System.out.println("结束连接");
}
}
服务器端代码
public class SocketSever {
private final static String DESK_PATH = "C:"+ File.separator+"Users"+File.separator+"admin_peng"+File.separator
+"Desktop"+File.separator+"IODIR"+File.separator;
public static void main(String[] args) throws IOException {
openServer();
}
public static void openServer() throws IOException {
//创建服务器并且注册到选择器中
Selector selector = Selector.open();
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(8080));
serverSocketChannel.configureBlocking(false);
SelectionKey sscKey = serverSocketChannel.register(selector, 0, null);
sscKey.interestOps(SelectionKey.OP_ACCEPT);
while(true){
selector.select();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
FileOutputStream outputStream = new FileOutputStream(new File(DESK_PATH+"copy文件.txt"));
FileChannel fileChannel = outputStream.getChannel();
Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();
while(selectedKeys.hasNext()){
SelectionKey key = selectedKeys.next();
//每次使用key之后要从selectorKeys集合中移除，否则下次遍历时如果为OP_ACCEPT实践接收到的请求可能为空，出现空指针异常
selectedKeys.remove();
if(key.isAcceptable()){
System.out.println("检测到accept请求");
ServerSocketChannel server = (ServerSocketChannel)key.channel();
server.configureBlocking(false);
SocketChannel socketChannel = server.accept();
socketChannel.configureBlocking(false);
SelectionKey scKey = socketChannel.register(selector, 0, null);
scKey.interestOps(SelectionKey.OP_READ);
System.out.println("处理完accept请求");
}else if(key.isReadable()){
System.out.println("监测到read请求");
SocketChannel socketChannel = (SocketChannel)key.channel();
socketChannel.configureBlocking(false);
int read = socketChannel.read(byteBuffer);
if(read==-1){
key.cancel();
System.out.println("数据读取完毕");
}else{
byteBuffer.flip();
// fileChannel.write(byteBuffer);
System.out.println("此次读到了"+read+"个字节");
byteBuffer.clear();
}
}if(key.isConnectable()){
SocketChannel socketChannel = (SocketChannel)key.channel();
if(socketChannel.finishConnect()){
System.out.println("连接成功 connected...");
}else{
System.out.println("连接失败 connected...");
}
}
}
}
}
}
使用原生的NIO常见的问题
- selectedKeys.remove() 在使用完selectionKey之后要将其从selectedKeys集合中移除，在selector中其实有两个集合，一个是select集合，一个是selectedKeys集合。前者保存所有这注册的key，后者则加入每次有事件响应的key，但是selectedKeys集合在遍历完后是不会清空的，这就需要我们自己清空，否则容易出现空指针异常。
- key.cancel() 在一个客户端出现异常或者客户端关闭时，会给服务器发送一个read操作，由于key一直存在于select集合中，那么关闭后也会一直发送read请求，造成服务端不停的select进入死循环，此时需要使用cancel从select集合反注册这个连接。同理，如果一个请求没有被处理就开始第二次select，那么也会进入死循环，在非阻塞IO中要保证所有事件都被处理。
扫一扫
594
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
