本文深入探讨了I/O模型的五种类型，包括阻塞I/O、非阻塞I/O、I/O多路复用、信号驱动I/O和异步I/O，通过生动的例子和代码演示，讲解了每种模型的工作原理和优缺点。
Netty学习之旅------第1篇---I/O模型学习
温馨提示：内容局限于本人的理解，如果有错误，请指正，谢谢！
学习目标：
（1）熟悉几种常见的I/O模型
（2）通过阻塞I/O、伪异步I/O的demo 了解它们是通信的基本流程。
常见的I/O模型主大致分为以下几种：阻塞I/O、非阻塞I/O 、 I/O 多路复用、信号驱动I/O、异步I/O ，越往后，可以说是I/O 进阶版本，下面一起来学习下。
1 阻塞I/O
阻塞I/O是传统的I/O, 需要同步等待内核准备好数据，才能返回。我们平时文件操作都是阻塞的。举个栗子，我要买一款新上市的手机，手机店没现货，要去仓库去调货，可能需要半小时或一小时不等。阻塞I/O就是一直在店里等着，直到手机调回来，如果手机一直没有来，我一直同步在店里面等待，效率很低。
2 非阻塞I/O
鉴于阻塞I/O的性能，有了非阻塞I/O，非阻塞I/O会立即返回，但是不断轮训内核是否准备好了数据。数据准备好了，就开始进行I/O读写的操作。在上面的案例中，就是我下单了，我继续去逛街或做其他事情，然后每隔一会来店里面询问下，手机是否准备好了。 这样虽然比阻塞I/O好多了，不用同步在店里面等待了，效率有所提升。但定时轮询，性能还是比较低，还是有点麻烦，继续往后看。
3 I/O 多路复用
分为2种：
3.1 select/poll
进程阻塞在select上，然后顺序扫描内核是否就绪。按照上面的案例，就是我找了个人来跑腿，他负责帮我定时去店里面查看准备情况，我每个10分钟打电话问下跑腿的人，如果准备好了，我再过去拿，这样频繁打电话还是麻烦，并且效率不高。
3.2 epoll
select/poll模型，受句柄受限制，不能处理太多的并发，于是有了epoll模型，epoll是基于事件驱动的。 我找了跑腿的人（比较靠谱），他负责去店里面查看手机准备情况，如果准备好了，他直接打电话给我，通知我过去拿。这里的优势是：不用我亲自再打电话过去了。
3.3 I/O多路复用的总结：
当需要同时处理多个客户端的请求是，可以利用多线程或I/O多路复用技术来处理，I/O 多路复用会把多个I/O阻塞在select上，从而使得，单线程可以处理并发的请求。优势是：资源占用小，易于维护。
4 信号驱动I/O
这是非阻塞的I/O, 在内核数据就绪时，通过信号回调来读取数据。比如我买手机的时候，我留了联系方式给手机店，手机店把货准备好了，再打电话给我过去拿。这样就省去了轮询的麻烦。
5 异步I/O
异步I/O 告知内核 启动某个操作，并且内核在完成后，通知我们，与信号驱动的不同之处，就是信号驱动I/O是通知你可以来读了， 异步I/O 模型由内核通知我们，操作何时完成。 这就更厉害了， 买手机的时候，填个收货地址，手机直接邮寄过来，等手机到了，然后告诉我，手机店通知我手机已经送达了。
6 几种I/O模型的功能和特性对比
可以看出同步I/O的优势是简单，但客户端线程和I/O线程是1:1，意味着多少个客户端，就需要新建多少个服务器线程来处理请求。当客户端达到一定的数量，服务器就无法及时处理了。并且浪费服务器的大量资源。
伪异步I/O，其实就是通过了服务器端线程池的概念来维护一定数目的活跃线程，客户端发送请求过来了，就从线程池中选取一个线程来处理客户端请求。
非阻塞I/O 的缺点是编码非常复杂，很容易出错。但是实现了非阻塞，吞吐量也很高。
异步I/O 是真正的异步非阻塞I/O，这个底层很复杂，是否支持AIO,依靠操作系统。
7 I/O demo
通过上面几种I/O的学习，我编写了对应的demo（没有考虑半包读写的问题），源码的地址，我会在文章末尾贴出来。
7.1 同步阻塞I/O
Server.java
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @Auther: chen
* @Date:
* @Description:
*/
public class Server {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
try {
serverSocket = new ServerSocket(9091);
while (true) {
socket = serverSocket.accept();
System.out.println("客户端来连接了");
new Thread(new ServerHandle(socket)).start();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(null!=socket){
try {
System.out.println("处理完，关闭连接");
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
ServerHandle.java
import java.io.*;
import java.net.Socket;
/**
* @Auther: chen
* @Date:
* @Description:
*/
public class ServerHandle implements Runnable{
Socket socket;
public ServerHandle(Socket accept) {
this.socket = accept;
}
@Override
public void run() {
BufferedReader in = null;
PrintWriter out = null;
try {
InputStream inputStream = socket.getInputStream();
InputStreamReader reader = new InputStreamReader(inputStream);
in = new BufferedReader(reader);
out = new PrintWriter(socket.getOutputStream(), true);
while (true){
String body = in.readLine();
if(null==body){
break;
}
System.out.println("接收到服务器发送来的数据："+body);
out.println("服务器收到了");
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(null!=in){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null!=out){
out.close();
}
}
}
}
Client.java
import java.io.*;
import java.net.Socket;
/**
* @Auther: chen
* @Date:
* @Description:
*/
public class Client {
public static void main(String[] args){
BufferedReader in = null;
PrintWriter out = null;
Socket socket = null;
try {
socket = new Socket("127.0.0.1",9091);
InputStream inputStream = socket.getInputStream();
InputStreamReader reader = new InputStreamReader(inputStream);
out = new PrintWriter(socket.getOutputStream(), true);
out.println("我是客户端");
System.out.println("向客户端发送消息");
in = new BufferedReader(reader);
System.out.println(in.readLine());
} catch (IOException e) {
e.printStackTrace();
}finally {
if(null!=in){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null!=out){
out.close();
}
if(null!=socket){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
看下执行效果：
Client：
Server：
Server.java 监听9091端口，阻塞在serverSocket.accept()这一行，并且每一个Client来连接，都创建一个服务的线程来处理Client的请求，这样并发大的情况下，服务器资源明显无法满足。这里是一个Client 对应一个服务器线程。
7.2 伪异步I/O
Server.java
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @Auther: chen
* @Date:
* @Description:
*/
public class Server {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
try {
serverSocket = new ServerSocket(9091);
while (true) {
socket = serverSocket.accept();
System.out.println("客户端来连接了");
ThreadPoolServer threadPoolServer = new ThreadPoolServer(3,5,3);
threadPoolServer.execute(new ServerHandle(socket));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(null!=socket){
try {
System.out.println("处理完，关闭连接");
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
ThreadPoolServer.java
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Auther: chen
* @Date:
* @Description:
*/
public class ThreadPoolServer {
ExecutorService executorService = null;
public ThreadPoolServer(int corePoolSize, int maximumPoolSize, int queueSize) {
executorService = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
100L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(queueSize));
}
public void execute(Runnable task){
executorService.execute(task);
}
}
ServerHandle.java 和Client.java 还是用上面,看下执行效果：
Client：
Server：
分析：
伪异步和同步相比，有了很大的提升，不会为每个Client创建线程，而是维持了一个线程池来处理任务，变的可控。但它的读写还是同步阻塞的，并没有从根本上解决问题。
8 总结
这篇文章，重点关注下几种I/O的概念和阻塞I/O、伪异步I/O的demo。
扫一扫
5006
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
