输入IO与输出IO原理
内核态: CPU可以访问内存所有数据, 包括外围设备, 例如硬盘, 网卡；
用户态: (独立创建应用程序) 只能受限的访问内存, 且不允许访问外围设备. 占用CPU的能力被剥夺, CPU资源可以被其他程序获
1、BIO(Blocking I O) 同步阻塞模型： 一个线程对应一个客户端连接。
应用场景:BIO方式适用于连接数目比较小且固定的架构， 这种方式对服务器资源要求比较高， 但程序简单易理解。
2、NIO(Non Blocking I O) 同步非阻塞：服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到 多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理。
应用场景:NIO方式适用于连接数目多且连接比较短（轻操作） 的架构， 比如聊天服务器， 弹幕系统， 服务器间通讯，编程比较复杂， JDK1.4 开始支持
3、AIO(NIO 2.0) 异步非阻塞：由操作系统完成后回调通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。是在NIO的基础上进一步封装的。
应用场景：AIO方式适用于连接数目多且连接比较长（重操作） 的架构，JDK7 开始支持
同步和异步的区别 同步和异步的区别
简单理解同步与异步：
同步也就是程序从上往下实现执行，顺序执行
异步从新开启一个新分支，相互不会影响，并行执行；
站在Http协议上分析同步与异步区别：
我们的Http协议请求默认情况下同步形式调用，如果调用过程非常耗时的情况下 客户端等待时间就非常长， 这种形式我们可以理解阻塞式；
解决办法：耗时的代码我们可以使用多线程或者MQ实现处理，但是不能立马获取结果； 客户端可以主动查询
阻塞与非阻塞的区别
阻塞: 如果我没有获取到结果的情况下，当前线程从运行状态切换为阻塞状态 内核角度分析：用户空间切换到内核空间
非阻塞：如果我没有获取到结果的情况下，当前的线程不会阻塞。
BIO(Blocking IO) 同步阻塞模型
一个线程处理一个客户端请求；
缺点：
1、IO代码里read操作是阻塞操作，如果获取不到数据的情况下，则会阻塞；
2、如果线程使用过多的情况下，非常消耗服务器端cpu的资源；
应用场景：
BIO 方式适用于连接数目比较小且固定的架构， 这种方式对服务器资源要求比较高
BIO客户端代码：
import java.io.IOException;
import java.net.Socket;
/***
* SocketBioClient
*/
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服务器端代码：
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @ClassName SocketBioServer
*/
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 (IOException e) {
e.printStackTrace();
}
}).start();
// handler(socket);
}
}
private static void handler(Socket socket) throws IOException {
System.out.println("线程id= " + Thread.currentThread().getId());
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("BIO阻塞效果演示完毕".getBytes());
socket.getOutputStream().flush();
}
}
NIO(Non Blocking IO) 同步非阻塞
NIO同步非阻塞的原理：多个客户端发送连接请求注册到（多路复用器）selector中，多路复用器使用轮训机制实现检测每个io请求有数据就进行处理。
底层实现原理：I/O多路复用底层一般用的Linux API（select，poll，epoll）来实现
NIO 有三大核心组件： Channel(通道)， Buffer(缓冲区)，Selector(选择器)
1.Channel(通道) :称之为通道，和IO相连，通信双方进行数据交流的通道，需要和buffer结合使用。
2.Buffer(缓冲区) :对数据的读取/写入需要使用buffer，buffer本质就是一个数组。
3.Selector(选择器): IO多路复用，一个线程Thread使用选择器Selector通过轮询的方式去监听多个通道Channel上的事件，从而让一个线程可以处理多个事件。
模拟NIO底层代码实现
import java.net.InetSocketAddress;
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;
/**
* 模拟伪装nio底层原理
* SocketNioTcpServer
*/
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通过轮询的方式去监听多个通道Channel上的事件，从而让一个线程可以处理多个事。I/O多路复用底层一般用的Linux API（select，poll，epoll）来实现
1.select：底层采用该数组方式存放 每次调用遍历的时间复杂度就是为O(n),有可能会产生空轮训，比如 保存1万个连接，最终只有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);
注意：windows操作系统是没有epoll，只有linux系统才有epoll
