69 netty 深度源码解读
1，同步与异步的/阻塞与非阻塞IO概念
2，linux 用户态与内核态之间的区别
3， 从linux内核角度分析非阻塞IO的原理
4，内核角度分析：读取与IO的原理
5，accept()与read（）方法之间的区别
6，使用BIO通讯存在哪些优缺点
7，简单模拟IO多路复用底层实现原理
8， IO 多路复用select/poll/epoll时间复杂度对比
BIO,NIO，AIO 模型
输入IO 与输出IO 原理
内核态：cpu可以访问内存的所有数据，包括外围设备，例如硬盘，网卡；
用户态： （独立创建应用程序）只能受限的访问内存，且不允许访问外围设备。占用cpu能力被剥夺，cpu资源可以被其他程序获取
image.png
1，BIO(Blocking I O) 同步阻塞模型，一个线程对应一个客户端连接
应用场景：
BIO 方式适用于连接数目比较小的且固定的架构，这种方式对服务器资源要求比较高，但是程序简单容易理解。
2，NIO(Non Blocking IO)同步非阻塞
服务器实现模式为一个线程可以处理多个请求（连接），客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理
应用场景：
NIo方式适用于连接数目多且比较短（轻操作）的架构，比如聊天服务器，弹幕系统。服务器间通讯，编程比较复杂。jdk1.4开始。
3，AIO(NIO2.0)异步非阻塞
由操作系统完成后回调通知服务端程序启动线程去处理，一般适用于连接数较多且连接较长的应用。是在NIO的基础上进一步封装的。
应用场景：
AIO 方式适用于连接数目多，且连接比较长(重操作)的架构。jdk7开始支持
同步和异步的区别：
同步也就是程序从上到下实现执行；
异步是重新开启一个新的分支，相互不影响：
站在http协议上分析同步与异步的区别：
我们的http协议请求默认情况下同步形成调用，如果调用过程中非常耗时的情况下 客户端等待时间就非常长，这种形式我们可以理解阻塞式。
解决办法： 耗时的代码我们可以使用多线程或者MQ实现处理，但是不能立马获取结果： 客户端可以主动查询：
image.png
image.png
阻塞和非阻塞的区别：
阻塞： 如果我没有获取到结果的情况下，当线程从运行状态切换到阻塞状态 ，内核角度分析： 用户空间切换到内核空间。
非阻塞： 如果我没有获取到结果的情况下，当前的线程不会阻塞。
image.png
BIO(Blocking IO)同步阻塞模型。
一个线程处理一个客户端请求：
缺点：
1，IO代码里read操作是阻塞操作，如果获取不到数据的情况下，则会阻塞，如果线程使用过多的情况下，非常消耗cpu资源：
应用场景：
BIO 方式适用于连接数目比较小且固定的架构，这种服务器资源要求比较高；
image.png
BIO 客户端：
package com.taotao.netty.bio;
import java.io.IOException;
import java.net.Socket;
/**
*@author tom
*Date 2020/11/8 0008 10:29
*
*/
public class SocketBioClient {
public static void main(String[] args) throws IOException {
Socket socket=new Socket("127.0.0.1",9001);
//向服务端发送数据
socket.getOutputStream().write("来演示下同步阻塞Bio".getBytes()
);
socket.getOutputStream().flush();
System.out.println("向服务端发送数据结束");
byte[] bytes=new byte[1024];
//接收服务端回传的数据。\
socket.getInputStream().read(bytes);
System.out.println("接收到服务端的数据："+new String(bytes));
socket.close();
}
}
BIO 服务端
package com.taotao.netty.bio;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
*@author tom
*Date 2020/11/8 0008 10:37
*
*/
public class SocketBioServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket=new ServerSocket(9001);
while (true){
System.out.println("服务端正在等待连接中....");
//阻塞方法 如果没有客户端与服务器端建立连接时，该方法会阻塞等待
final Socket socket=serverSocket.accept();
System.out.println("有客户端和我连接了");
//如果不使用异步线程处理接受io操作的情况下，有可能会阻塞等待 无法接受新的连接请求;
new Thread(()->{
try {
handler(socket);
}catch (Exception e){
e.printStackTrace();
}
}).start();
}
}
private static void handler(Socket socket) throws IOException {
System.out.println("线程id="+Thread.currentThread());
byte[] bytes=new byte[1024];
System.out.println("开始read..");
//接收客户端的数据，如果没有读取到客户端数据时，该方法也会阻塞
int read=socket.getInputStream().read(bytes);
System.out.println("read结束");
if(read!=-1){
System.out.println("接收到客户端的数据："+new String(bytes,0,read));
System.out.println("线程id=="+Thread.currentThread().getId());
}
socket.getOutputStream().write("效果演示完毕".getBytes());
socket.getOutputStream().flush();
}
}
NIO（Non Blocking Io）同步非阻塞
NIO同步非阻塞的原理： 多个客户端发送连接请求注册到(多路复用器)selector中。多路复用器使用轮询机制实现检测每个io请求有数据就进行处理。
i/o多路复用底层一般用的linuxAPI(select,poll,epoll)来实现；
image.png
NIO 有三大核心组件：channel(通道),buffer(缓冲区),selector(选择器)
1，channel(通道)：称之为通道。和io相连，通信双方进行数据交流的通道，需要和buffer结合使用。
2，buffer（缓冲区）： 对数据的读取/写入需要使用buffer,buffer 本质就是一个数组。
3，selector(选择器): Io多路复用 一个线程Thread使用选择器Selector通过轮询的方式去监听多个通道channnel上的事件，从而让一个线程可以处理多个事件。
简单模拟NIO 底层代码实现。
package com.taotao.netty.nio;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
/**
*@author tom
*Date 2020/11/8 0008 14:22
*
*/
public class SimulationNioTcpServer {
/**
* 保存SocketChannel
*/
private static List<SocketChannel> listSocketChannel = new ArrayList<>();
/**
* 缓冲区大小
*/
private static ByteBuffer byteBuffer = ByteBuffer.allocate(512);
public static void main(String[] args) {
try {
// 1.创建一个ServerSocketChannel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 2. 绑定地址
ServerSocketChannel bind = serverSocketChannel.bind(new InetSocketAddress(8080));
// 3.设置非阻塞模式
serverSocketChannel.configureBlocking(false);
while (true) {
// 4.等待建立连接 如果设置非阻塞的情况下，如果没有获取连接的情况下直接返回null，如果建立连接之后返回socketChannel
// 建立三次握手
SocketChannel socketChannel = serverSocketChannel.accept();
// 5. 如果socketChannel 不为空的情况下，则将该连接保存起来。
if (socketChannel != null) {
// 设置该socketChannel通道为fasle
socketChannel.configureBlocking(false);
listSocketChannel.add(socketChannel);
}
// 循环SocketChannel,检查每个SocketChannel中数据有传输数据
for (SocketChannel scl : listSocketChannel) {
try {
// 6.以缓冲区方式读取
int read = scl.read(byteBuffer);
if (read > 0) {
byteBuffer.flip();
// 转换格式为中文的格式
Charset charset = Charset.forName("UTF-8");
String receiveText = charset.newDecoder().decode
(byteBuffer.asReadOnlyBuffer()).toString();
System.out.println("receiveText:" + receiveText);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
选择器IO 多路复用底层原理：
IO 多路复用原理 一个线程Thread 使用选择器Selector 通过轮询的方式去监听多个通道Channnel上的事件，从而让一个线程可以处理多个事件。
I/o 多路复用底层一般用的linuxAPI（select,poll,epoll）来实现；
image.png
1，使用select的情况下，底层采用该数组的方式存放，每次调用遍历的时间复杂度就是为o(n)，有可能产生空轮询，比如保存1万个连接，最终只有一个连接有传输数据。
2，使用poll 底层采用链表结构存放，每次调用遍历的时间复杂度就是为o(n)
Poll 和select之间的区别不是很大： select监视器单个进程可监视的fd数量被限制，可以通过cat、proc、sys/fs、file-max,poll是没有监视的fd数量限制。
linux服务器中创建Socket服务器端，单个select 进程可监视的fd(连接数据)限制
3，epoll 采用事件通知回调方式，避免空轮休，时间复杂度o(1)
for(fds){
文件描述符，数据准备好的情况下，在以事件回调的方式通知给服务器端。
}
注意： windows 操作系统是没有epoll，只有linux 系统才有epoll
Nginx、redis nio模型
redis 官网中是否有提供windows redis 大牛人物改写Redis源码能够使用
Select 选择实现。
