Netty之前使用过，但仅仅是用的程度，现在仔细学习一下原理性知识！废话不多，开始！
I/O模型
一、Java共支持3种网络编程模型：BIO、NIO、AIO
1、BIO同步并阻塞（传统阻塞型）
服务器实现模式为一个连接一个线程，即客户端连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销；
BIO代码示例演示：
package netty.bio;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @description: java BIO示例
* @author: xch
* @time: 2021/5/10 20:33
*/
public class BioServer {
public static void main(String[] args) throws IOException {
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
ServerSocket serverSocket = new ServerSocket(6666);
System.out.println("服务器启动了");
while (true) {
//监听 等待客户端连接
//(第一个阻塞点：阻塞等待下一个连接)
final Socket socket = serverSocket.accept();
System.out.println("连接到一个客户端");
//创建一个线程池，与之通讯
newCachedThreadPool.execute(new Runnable() {
@Override
public void run() {
handler(socket);
}
});
}
}
//编写一个handler方法,和客户端通讯
public static void handler(Socket socket) {
try(InputStream inputStream = socket.getInputStream()) {
byte[] bytes = new byte[1024];
while (true) {
//(第二个阻塞点，阻塞等待后续的输入流)
int read = inputStream.read(bytes);
if (read != -1) {
System.out.println(new String(bytes, 0, read));
} else {
break;
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
2、NIO同步非阻塞
服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理；
- 每个channel对应一个Buffer；
- Selector对应一个线程，一个线程对应多个channel（连接）；
- 该图反应了有三个channel注册到了该selector；
- 程序切换到哪个channel是由事件决定，Event重要概念；
- Selector会根据不同的事件，在各个channel通道上切换；
- Buffer就是一个内存块，底层是一个数组结构；
- 数据的读取写入都是通过Buffer；
- channel是双向的，可以反映底层操作系统的情况，如linux底层操作系统通道就是双向的；
3、AIO异步非阻塞
AIO引入异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才会启动线程，特点是先有操作系统完成后才会通知服务器程序启动线程去处理，一般适用于连接较多且连接时间长的应用；
4、BIO、NIO、AIO适用场景
- BIO方式适用于连接数目较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序简单容易理解；
- NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器之间的通讯等。编程比较复杂，JDK1.4开始支持；
- AIO方式适用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持；
二、Buffer
Buffer类定义了所有的缓冲区都具有四个属性来提供，所包含的数据元素的信息
- Capacity 容量，即可以容纳的最大数据量；在缓冲区创建时被设定，不能改变；
- Limit 表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改的；
- Position 位置，下一个要被读或者写的元素的索引，每次读写缓冲区数据时都会改变值，为下次读写做准备；
- Mark 标记
三、Channel
- 通道类似于流，区别： a: 通道是可以同时进行读写，而流只能读或者只能写； b: 通道可以实现异步读写数据； c: 通道可以从缓冲读数据、也可以写数据到缓冲；
- BIO中的stream是单向的，例如FileInputStream对象只能进行读取数据操作；而NIO中的Channel通道是双向的，可以读操作、也可以写操作；
- Channel在Nio中是一个接口 public interface Channel extends Closeable{}；
- 常用的Channel类有：FileChannel、DatagramChannel、ServerSocketChannel 和 SocketChannel；【ServerSocketChannel 类似 ServerSocket， SocketChannel 类似 Socket】
写入和读出 流程示例图：
四、Selector
上图说明：
- 当客户端连接时，会通过ServerSocketChannel得到SocketChannel；
- 将socketChannel注册到Selector上，register(Selector sel, int ops)，一个selector上可以注册多个SocketChannel；
- 注册后返回一个SelectionKey，会和该Selector关联（集合）；
- Selector进行监听select()方法，返回有事件发生的通道个数；
- 进一步得到各个SelectionKey（有事件发生）；
- 再通过SelectionKey反向获取SocketChannel，使用方法channel(），
- 得到Channel后，完成相关业务处理；
上图代码示例：
服务端NIOServer
package com.study.demo.nio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
public class NIOServer {
public static void main(String[] args) throws Exception {
//创建ServerSocketChannel -> ServerSocket
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//得到一个Selector
Selector selector = Selector.open();
//绑定一个端口6666，在服务器端监听
serverSocketChannel.socket().bind(new InetSocketAddress(6666));
//设置为非阻塞
serverSocketChannel.configureBlocking(false);
//把ServerSocketChannel注册到selector 关心事件是OP_ACCEPT
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
//这里我们等待1秒，如果没有事件发生，返回
if(selector.select(1000) == 0) {
System.out.println("服务器等待了1秒，无连接");
continue;
}
//如果返回的 >0，就获取相关的selectionKey集合
//1、如果返回的>0，表示已经获取到关注的事件
//2、selector.selectedKeys()返回关注事件的集合
// 通过Set<SelectionKey>,使用迭代器遍历
Set<SelectionKey> selectionKeys= selector.selectedKeys();
//遍历Set<SelectionKey>,使用迭代器遍历
Iterator<SelectionKey> keyIterable = selectionKeys.iterator();
while(keyIterable.hasNext()) {
//获取到SelectionKey
SelectionKey key = keyIterable.next();
//根据key 对应的通道发生的事件做相关处理
if(key.isAcceptable()) {
//该客户端生产一个SocketChannel
SocketChannel socketChannel = serverSocketChannel.accept();
socketChannel.configureBlocking(false);
System.out.println("客户端连接成功 生产一个socketChannel " + socketChannel.hashCode());
//将SocketChannel 注册到selector, 关注事件是OP_READ,同时给socketChannel关联一个Buffer
socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
}
//发生 OP_READ事件
if(key.isReadable()) {
//通过key 反向获取到对应的channel
SocketChannel channel = (SocketChannel)key.channel();
//获取到channel关联的Buffer
ByteBuffer buffer = (ByteBuffer) key.attachment();
channel.read(buffer);
System.out.println("from 客户端 " + new String(buffer.array()));
}
//手动移除当前的selectionKey,防止重复操作
keyIterable.remove();
}
}
}
}
客户端NIOClient
package com.study.demo.nio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class NIOClient {
public static void main(String[] args) throws Exception {
//得到一个网络通道
SocketChannel socketChannel = SocketChannel.open();
//设置非阻塞
socketChannel.configureBlocking(false);
//提供服务端的ip和端口
InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
//连接服务器
if(!socketChannel.connect(inetSocketAddress)) {
while (!socketChannel.finishConnect()) {
System.out.println("因为连接需要时间，客户端不会阻塞，可以做其他工作...");
}
}
//如果连接成功 则发送数据
String str = "haha 连上你了";
//wrap(byte[])可以根据字节数 来创建一个对应大小的字节数组到buffer
ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
//发送数据，实际就是 将buffer数据写入channel
socketChannel.write(buffer);
System.in.read();
}
}
演示效果：
服务器等待了1秒，无连接
服务器等待了1秒，无连接
服务器等待了1秒，无连接
客户端连接成功 生产一个socketChannel 159413332
from 客户端 haha 连上你了
服务器等待了1秒，无连接
服务器等待了1秒，无连接
服务器等待了1秒，无连接
服务器等待了1秒，无连接
服务器等待了1秒，无连接
客户端连接成功 生产一个socketChannel 500977346
from 客户端 haha 连上你了
服务器等待了1秒，无连接
服务器等待了1秒，无连接
扫一扫
1068
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
