网络编程（一）：服务器模型、Java I/O模型、Reactor事件处理模型、I/O复用
文章目录
- 一、Socket和TCP/IP协议族的关系
- 二、服务器模型
-
- 1.C/S模型（Client/Server Model）
- 2.P2P模型（Peer-to-Peer Model）
- 三、Java的I/O演进
-
- 1.BIO（阻塞）
-
- （1）工作流程
- （2）代码实现
- 2.NIO（多路复用/轮询）
-
- （1）工作流程
- （2）代码实现
- 3.NIO2.0——AIO（异步/事件驱动）
- 四、并发事件处理模式
-
- 1.Reactor模式（NIO）
-
- （1）单Reactor单线程模型
- （2）单Reactor多线程模型（Redis）
- （3）主从Reactor多线程模型（Netty）
- 2.Proactor模式（AIO）
- 五、I/O复用
一、Socket和TCP/IP协议族的关系
Socket和TCP/IP协议族是网络编程中的两个重要概念，它们之间存在密切的关系。
首先，TCP/IP协议族是一组用于互联网通信的网络协议的集合。它由多个协议组成，其中最核心的协议是TCP（Transmission Control Protocol）和IP（Internet Protocol）。TCP协议提供可靠的数据传输和连接管理，而IP协议则负责将数据包从源地址传输到目的地址。
Socket是一种抽象概念，它提供了应用程序与网络之间的接口。通过Socket，应用程序可以通过网络与其他应用程序进行通信。在编程语言中，Socket通常被封装成库或API，以提供方便的网络编程接口。
TCP/IP协议族中的TCP协议使用Socket来实现端到端的数据传输。在TCP/IP网络中，每个主机都有一个唯一的IP地址，而每个运行TCP协议的应用程序都使用一个Socket来标识自己。一个Socket由IP地址和端口号组成，用于唯一标识网络中的一个应用程序。
当应用程序使用Socket进行网络通信时，它可以创建一个Socket对象，并指定目标主机的IP地址和端口号。通过Socket对象，应用程序可以使用TCP协议建立与目标主机的连接，并进行数据的发送和接收。TCP协议负责将数据分割成小的数据包，并通过IP协议将这些数据包从源主机传输到目的主机。
总结来说，Socket是应用程序与网络之间的接口，而TCP/IP协议族则是网络通信的基础协议。通过Socket和TCP协议，应用程序可以在TCP/IP网络中进行可靠的数据传输和通信。
二、服务器模型
服务器模型是指在网络中进行通信和资源共享时所采用的不同架构模式。常见的服务器模型包括C/S模型（Client/Server Model）和P2P模型（Peer-to-Peer Model）。
1.C/S模型（Client/Server Model）
C/S模型是一种常见的服务器模型，其中客户端（Client）和服务器（Server）之间存在明确的角色和功能分工。
- 客户端：客户端是发起请求的一方，它向服务器发送请求并接收服务器的响应。客户端通常是一台终端设备，如个人计算机、智能手机等。
- 服务器：服务器是提供服务的一方，它接收客户端的请求并提供相应的服务或资源。服务器通常是一台高性能的计算机或设备，具备处理请求和提供服务的能力。
在C/S模型中，客户端和服务器之间通过网络进行通信。客户端发起请求，服务器接收请求并处理，然后将响应发送回客户端。这种模型可以实现中心化的控制和管理，服务器负责处理和存储数据，客户端主要负责用户界面的展示和交互。
2.P2P模型（Peer-to-Peer Model）
P2P模型是一种去中心化的服务器模型，其中参与通信的设备之间平等地协作，没有明确的客户端和服务器的区别。
- 对等节点：在P2P模型中，所有参与通信的设备都是对等节点，它们既是服务的提供者，也是服务的请求者。每个节点都可以与其他节点直接通信，共享资源或提供服务。
在P2P模型中，设备之间通过直接连接进行通信，而不依赖于中央服务器。每个设备既可以发起请求，也可以响应其他设备的请求，实现了资源和服务的共享。P2P模型常用于文件共享、实时通信等场景，例如BitTorrent协议就是一种典型的P2P协议。
总结来说，C/S模型是一种中心化的服务器模型，客户端和服务器之间存在明确的角色和功能分工；而P2P模型是一种去中心化的服务器模型，参与通信的设备平等地协作，共享资源和服务。选择适合的服务器模型取决于具体的应用需求和网络架构。
三、Java的I/O演进
1.BIO（阻塞）
网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息（绑定的IP地址和监听端口），客户端通过连接操作向服务端监听的地址发起连接请求，通过三次握手建立连接，如果连接建立成功，双方就可以通过网络套接字(Socket)进行通信。
在基于传统同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功之后，双方通过输入和输出流进行同步阻塞式通信。
BIO，即Blocking IO，阻塞型I/O。阻塞体现在两个地方，连接线程的阻塞和读写的阻塞。
（1）工作流程
服务端启动ServerSocket；
客户端启动 Socket 对服务器进行通信，服务端对每个客户端建立一个线程与之通讯（可以使用线程池进行优化）；
客户端发出请求后，先咨询服务器是否有线程响应，如果没有则会等待（即阻塞）；
如果有响应，客户端线程会等待请求结束后，再继续执行。
（2）代码实现
- 服务端：
package bio;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class BIOServer {
//创建一个线程池，用于处理客户端连接后的工作
public static ThreadPoolExecutor pool=new ThreadPoolExecutor(10, 10, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
public static void main(String[] args) throws IOException{
ServerSocket serverSocket=new ServerSocket(8888);
while(true){
//1 等待客户端连接是阻塞的
Socket socket=serverSocket.accept();
System.out.println("客户端连接上了");
//2 连接上以后向线程池提交一个任务用于处理连接
pool.execute(new Runnable() {
@Override
public void run() {
while(true){
try{
//读写也是阻塞的
//创建输出流，server向client输出
PrintStream printStream = new PrintStream(socket.getOutputStream());
printStream.println("message from server 8888");
printStream.close();
socket.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
});
}
}
}
- 客户端：
package bio;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
public class BIOClient {
public static void main(String[] args) throws IOException{
Socket socket = new Socket("127.0.0.1", 8888);
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println("This message comes from server:"+bufferedReader.readLine());
bufferedReader.close();
socket.close();
}
}
- 缺点：
- accept()等待客户端连接是阻塞的，有时候需要进行无谓的等待，效率低下，浪费资源。
- 引入线程池进行优化提升了高并发能力，即能够同时处理多个客户端请求了，但是却带来了一个问题，随着开启的线程数目增多，将会消耗过多的内存资源，导致服务器变慢甚至崩溃。
- 读写操作仍然是阻塞的，如果客户端半天没有操作，也会浪费资源，因此效率不高。
2.NIO（多路复用/轮询）
NIO，即non-blocking lO，非阻塞型IO。
-
非阻塞——减少线程资源的浪费：
BIO提供非阻塞读写模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。可以做到 用一个线程来处理多个操作，体现了一种多路复用的思想。 而不是像BIO那样，一个连接过来就得分配一个线程，造成资源的浪费。 -
处理数据的方式：
BIO 以流的方式处理数据，而 NIO 以缓冲区（也被叫做块）的方式处理数据，块 IO 效率比流 IO 效率高很多。BIO 基于字符流或者字节流进行操作，而 NIO 基于 Channel 和 Buffer 进行操作，数据总是从通道读取到缓冲区或者从缓冲区写入到通道。 -
复用：
Selector(选择器)用于监听多个通道的事件（比如连接请求，数据到达等)，因此使用单个线程就可以监听多个客户端通道。
（1）工作流程
Channel(通道)，Buffer(缓冲区), Selector(选择器)为NIO的三大核心组件。
-
Channel(通道)：
相比于BIO流的读写，Channel的读写是双向的，既可以从通道中读取数据，又可以写数据到通道。通道可以非阻塞读取和写入通道/缓冲区，也支持异步地读写。 -
Buffer(缓冲区)：
在客户端和Channel之间，增加Buffer缓冲区的支持，更加容易操作和管理。 -
Selector(选择器)：
用来 轮询 检查一个或多个NIO通道，并确定哪些通道已经准备好进行读取或写入。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接，提高效率。
（2）代码实现
代码来自：here
- 服务端：
package nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
public class NIOServer {
public static void main(String[] args) throws IOException {
// 创建ServerSocketChannel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 创建一个Selector对象,
Selector selector = Selector.open();
// 绑定端口6666, 在服务器端监听
serverSocketChannel.socket().bind(new InetSocketAddress(6666));
// 设置为非阻塞
serverSocketChannel.configureBlocking(false);
// 把serverSocketChannel注册到selector
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
// 循环等待用户连接
while (true){
if (selector.select(1000) == 0){ //等待(阻塞)一秒, 没有事件发生
// if (selector.selectNow() == 0){ // 也可以设置成非阻塞的
System.out.println("服务器等待了一秒,无连接");
continue;
}
// 如果返回的>0 , 说明客户端有了动作，就获取相关的selectionKey集合
Set<SelectionKey> selectionKeys = selector.selectedKeys(); // 返回关注事件的集合
// 遍历selectionKeys
Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
while (keyIterator.hasNext()){
// 获取到selectionKey
SelectionKey key = keyIterator.next();
//根据key对应的通道获取事件并做相应处理
if (key.isAcceptable()){
//如果是OP_ACCEPT, 表示有新的客户端产生
//给该客户端生成SocketChannel
SocketChannel socketChannel = serverSocketChannel.accept();
//将socketChannnel设置为非阻塞
socketChannel.configureBlocking(false);
//将socketChannel注册到selector上, 设置事件为OP_READ,同时给socketChannel关联一个buffer
socketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));
}
if (key.isReadable()){
// 发生了OP_READ
SocketChannel channel=(SocketChannel)key.channel();
ByteBuffer buffer = (ByteBuffer)key.attachment();
channel.read(buffer);
System.out.println("from 客户端"+new String(buffer.array()));
}
// 手动从集合中移除当前的selectionKey, 防止多线程情况下的重复操作
keyIterator.remove();
}
}
}
}
- 客户端：
package nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class NIOClient {
public static void main(String[] args) throws IOException {
// 获取一个网络通道
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 = "hello world";
ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
// 发送数据 , 将buffer中的数据写入到channel中
socketChannel.write(buffer);
System.in.read();
}
}
3.NIO2.0——AIO（异步/事件驱动）
AIO，即Asynchronous I/O，异步非阻塞IO。AIO提供的最大的特点是具备异步功能，采用“订阅-通知”模式，即应用程序向操作系统注册IO监听，然后继续做自己的事情。当操作系统发生IO事件，并且准备好数据后，在主动通知应用程序，触发相应的函数。
下面是一段简单的代码示例：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.Future;
public class NIO2AsyncFileIOExample {
public static void main(String[] args) {
try {
// 通过路径获取文件通道
Path path = Paths.get("test.txt");
AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(
path, StandardOpenOption.READ, StandardOpenOption.WRITE);
// 分配缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 异步读取文件
Future<Integer> readResult = fileChannel.read(buffer, 0);
while (!readResult.isDone()) {
// 在等待异步读取完成时可以进行其他操作
System.out.println("Waiting for read operation to complete...");
}
// 打印读取结果
buffer.flip();
System.out.println("Read data: ");
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
System.out.println();
// 异步写入数据
String newData = "Hello, NIO 2.0!";
buffer.clear();
buffer.put(newData.getBytes());
buffer.flip();
Future<Integer> writeResult = fileChannel.write(buffer, 0);
while (!writeResult.isDone()) {
// 在等待异步写入完成时可以进行其他操作
System.out.println("Waiting for write operation to complete...");
}
System.out.println("Data written to file.");
// 关闭文件通道
fileChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
四、并发事件处理模式
1.Reactor模式（NIO）
使用 Java NIO 构建的 IO 程序，它的工作模式是：主动轮训 IO 事件，IO 事件发生后程序的线程主动处理 IO 工作，这种模式也叫做 Reactor 模式。
（1）单Reactor单线程模型
只有一个线程来执行所有的任务，效率低下，并且也有可靠性问题。
（2）单Reactor多线程模型（Redis）
相比于上一个模型，增加了线程池的支持，从一定程度上提升了并发效率，但是引入线程池可能会涉及到数据同步问题。Redis底层就是基于这种模型。
（3）主从Reactor多线程模型（Netty）
在上一个模型的基础上，一个Reactor变成了两个，主Reactor创建连接，从Reactor分发读写任务，能支持更高的并发量。Netty是基于这种模型。
2.Proactor模式（AIO）
使用 Java AIO 构建的 IO 程序，它的工作模式是：将 IO 事件的处理托管给操作系统，操作系统完成 IO 工作之后会通知程序的线程去处理后面的工作，这种模式也叫做 Proactor 模式。
现在AIO和Proactor使用还不怎么广泛。
五、I/O复用
select、poll、epoll