找回密码
立即注册
搜索
热搜: Java Python Linux Go
云栈社区»论坛 › 站务中心「 Forum Service 」 › Linux高性能网络编程：Socket调用与内核协议栈调优实战 ...
发回帖 发新帖
linuxx

3024

积分

0

好友

417

主题

Linux高性能网络编程：Socket调用与内核协议栈调优实战

发表于 2 小时前 | 查看: 0| 回复: 0

在云计算、微服务与高并发架构成为主流的当下，网络性能直接决定系统的承载上限与响应效率。高性能网络编程已成为开发者必备的核心能力。Socket作为用户态与内核态交互的核心接口，其调用方式的合理性，与内核协议栈的运行效率，共同构成了网络通信的性能基石。我们常会发现，许多系统性能瓶颈并非源于业务逻辑，而是隐藏在对Socket API的不当使用，以及内核协议栈的默认配置与实际业务场景的不匹配之中。

从底层的字节流传输到上层的高并发请求处理，从减少系统调用开销到优化TCP连接管理，Socket调用与内核协议栈调优贯穿了网络编程的全链路。本文将聚焦这两大核心维度，拆解关键技术要点，剖析性能瓶颈成因，并提供可落地的优化策略，旨在助力开发者突破网络性能的桎梏，构建出低延迟、高吞吐、高可靠的网络应用。

一、Socket 调用是什么？

1.1 Socket 基础概念

Socket，即套接字，是网络编程中的一个关键概念。它被形象地比喻为网络通信的“插座”，是应用程序与网络之间的接口。通过Socket，应用程序能够实现数据的发送和接收，进而进行网络通信。Socket提供了一种标准化的方式来建立网络连接，使得不同的计算机之间能够通过网络进行数据交换。

Socket的工作原理基于客户端-服务器模型。在这个模型中，Socket充当了通信端点的角色，允许应用程序在网络上发送和接收数据。它提供了一种抽象层，让应用程序无需关注底层的网络协议和硬件细节，从而降低了网络编程的复杂性。同时，Socket具有跨平台的特性，能够支持多种操作系统和编程语言，这使得开发者可以更加便捷地开发出通用的网络应用程序。

Socket主要分为两种类型：流Socket（Stream Socket）和数据报Socket（Datagram Socket）。流Socket也被称为TCP Socket，它基于TCP协议，提供可靠的、面向连接的通信。在数据传输过程中，流Socket会对数据进行分段和重组，确保数据的完整性和顺序。这种特性使得流Socket非常适合对数据准确性和顺序要求较高的应用场景，如文件传输、远程登录等。

数据报Socket也称为UDP Socket，它基于UDP协议，提供无连接的通信。数据报Socket以数据报的形式发送数据，传输速度较快，但不保证数据的可靠性和顺序。虽然UDP不提供可靠交付，不保证不丢失、不保证按顺序到达，但它在一些对传输速度要求较高，而对数据准确性和顺序要求相对较低的场景中具有优势，比如实时视频流传输、在线游戏中的实时数据传输等，少量的数据丢失或乱序可能并不会对整体的用户体验造成太大影响。

1.2 Socket 调用流程解析

以常见的TCP通信为例，Socket调用的完整流程如下：

  1. 创建 Socket：无论是客户端还是服务器端，首先都需要调用 socket() 函数创建一个Socket对象。该函数的原型为 int socket(int domain, int type, int protocol);。其中，domain参数指定协议族，如 AF_INET 表示 IPv4 协议族；type参数指定Socket类型，SOCK_STREAM 表示流套接字（用于TCP通信），SOCK_DGRAM 表示数据报套接字（用于UDP通信）；protocol参数通常设置为0，表示使用默认协议。创建Socket就像是在网络空间中开辟了一个通信端点，为后续的通信做好准备。
  2. 绑定地址：服务器端的Socket需要调用 bind() 函数绑定到一个特定的IP地址和端口号，函数原型为 int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);。sockfd 是之前创建的Socket描述符，addr 是一个指向包含IP地址和端口号等信息的结构体指针，addrlen 是该结构体的长度。绑定地址就好比给这个通信端点贴上一个明确的“地址标签”，以便客户端能够找到它。例如，一个Web服务器通常会绑定到80端口（HTTP协议默认端口）或443端口（HTTPS协议默认端口）。
  3. 监听连接（仅服务器端）：服务器端在绑定地址后，调用 listen() 函数进入监听状态，等待客户端的连接请求，函数原型为 int listen(int sockfd, int backlog);。sockfd 为Socket描述符，backlog 参数指定了等待连接队列的最大长度。这就像是服务器端在自己的“门口”设置了一个接待处，用来排队处理客户端的连接请求。
  4. 接受连接（仅服务器端）：当客户端发起连接请求时，服务器端通过调用 accept() 函数接受该请求，建立连接。函数原型为 int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);。sockfd 是监听的Socket描述符，addr 用于存储客户端的地址信息，addrlen 是该地址结构体的长度。accept() 函数会从等待连接队列中取出一个连接请求，如果队列为空，它会阻塞等待，直到有新的连接请求到来。一旦接受了连接请求，就会返回一个新的Socket描述符，这个新的Socket将用于与该客户端进行数据传输，而原来的监听Socket继续保持监听状态。
  5. 发起连接（仅客户端）：客户端在创建Socket后，通过调用 connect() 函数向服务器端发起连接请求，函数原型为 int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);。sockfd 是客户端的Socket描述符，addr 指向包含服务器端IP地址和端口号的结构体，addrlen 是该结构体的长度。
  6. 数据传输：一旦连接建立，客户端和服务器端就可以通过Socket进行数据的发送和接收。在TCP通信中，通常使用 read() 和 write() 函数（在不同的编程语言中可能有不同的函数名，但功能类似）来进行数据读写操作。例如，ssize_t read(int fd, void *buf, size_t count); 函数从指定的Socket描述符 fd 中读取最多 count 个字节的数据到缓冲区 buf 中；ssize_t write(int fd, const void *buf, size_t count); 函数则将缓冲区 buf 中的 count 个字节的数据写入到指定的Socket描述符 fd 中。
  7. 关闭连接：当数据传输完成后，双方需要调用 close() 函数关闭Socket连接，释放资源。close() 函数的原型为 int close(int fd);，fd 是需要关闭的Socket描述符。

1.3 Socket 调用关键要点

  1. 处理连接超时：在调用 connect() 函数发起连接请求时，可能会因为网络故障、服务器繁忙等原因导致连接长时间无法建立。为了避免程序长时间阻塞在连接操作上，需要设置连接超时时间。可以通过设置Socket的选项来实现，例如在Linux系统中，可以使用 setsockopt() 函数设置 SO_SNDTIMEO 和 SO_RCVTIMEO 选项来分别设置发送和接收数据的超时时间。
  2. 错误处理机制：Socket调用过程中可能会出现各种错误，如连接失败、读写错误等。因此，编写健壮的错误处理代码是非常重要的。在调用每个Socket函数后，都应该检查其返回值，判断是否发生了错误。如果发生错误，可以根据错误码进行相应的处理。
  3. 设置合适的缓冲区大小：Socket的缓冲区大小会影响数据传输的效率。如果缓冲区过小，可能会导致频繁的读写操作，增加系统开销；如果缓冲区过大，又可能会浪费内存资源。因此，需要根据实际的应用场景和数据流量来设置合适的缓冲区大小。可以通过 setsockopt() 函数设置 SO_SNDBUF 和 SO_RCVBUF 选项来分别设置发送和接收缓冲区的大小。

二、深入剖析协议栈架构

2.1 内核协议栈架构

内核协议栈是操作系统内核中负责网络协议处理的核心模块，它基于TCP/IP模型构建，通常包含网络接口层、网络层、传输层和应用层，各层相互协作，共同完成网络数据的传输与处理。

内核协议栈处理流程图

网络接口层是协议栈的最底层，负责与物理网络设备进行交互，实现数据帧的发送和接收。它主要包含设备驱动程序和网络接口卡（NIC）。例如，在以太网中，网络接口层会将数据封装成以太网帧，添加源MAC地址、目的MAC地址等信息，然后通过网络接口卡将帧发送到物理网络上。

网络层主要负责处理网络地址和路由选择，实现数据包在不同网络之间的传输。其核心协议是IP（网际协议）。除了IP协议，网络层还包括ICMP（互联网控制报文协议）和IGMP（互联网组管理协议）等辅助协议。

传输层负责提供端到端的通信服务，确保数据的可靠传输或高效传输。它主要包含TCP（传输控制协议）和UDP（用户数据报协议）两种协议。TCP是一种面向连接的、可靠的传输协议，它通过三次握手建立连接，在数据传输过程中，会对数据进行分段、编号、确认和重传等操作，以确保数据的完整性和顺序性。UDP是一种无连接的、不可靠的传输协议，它将数据封装成UDP数据报直接发送。

应用层是协议栈的最高层，它为应用程序提供网络服务接口，实现各种网络应用功能。常见的应用层协议有HTTP（超文本传输协议）、FTP（文件传输协议）、SMTP（简单邮件传输协议）、DNS（域名系统）等。

2.2 数据收发在协议栈中的流程

（1）数据发送流程：当应用层有数据需要发送时，首先会调用Socket接口将数据传递给传输层。如果使用TCP协议，传输层会将数据分割成适当大小的段（Segment），并为每个段添加TCP头部。若使用UDP协议，传输层则将数据封装成UDP数据报，添加UDP头部。

接着，传输层将封装好的段或数据报传递给网络层。网络层会为其添加IP头部，然后根据目的IP地址查询路由表，确定数据的下一跳地址，并将数据包转发到相应的网络接口。

网络接口层接收到网络层传来的数据包后，会根据下一跳地址查询ARP（地址解析协议）缓存表，获取对应的MAC地址。得到MAC地址后，网络接口层将数据包封装成数据帧（Frame），添加数据链路层头部和尾部，最后通过物理网络发送出去。

（2）数据接收流程：数据从物理网络到达接收端的网络接口层时，网络接口层首先会对接收到的数据帧进行校验。如果校验通过，则去除数据链路层头部和尾部，将数据包传递给网络层。

网络层接收到数据包后，会检查IP头部的目的IP地址是否为本机IP地址。如果是，则根据IP头部中的协议类型，将数据包传递给相应的传输层协议。

传输层接收到数据包后，如果是TCP协议，会根据TCP头部中的序列号和确认号对数据进行重组和确认。如果是UDP协议，传输层会直接将数据报传递给应用层。最后，应用层通过Socket接口接收传输层传递过来的数据。

2.3 内核协议栈与网络性能的紧密关系

内核协议栈对网络性能的影响是多方面的，它直接关系到网络的延迟、吞吐量和可靠性等关键性能指标。

在网络延迟方面，协议栈的处理速度起着关键作用。当数据在协议栈各层之间传递时，每一层都需要进行一定的处理操作。如果协议栈的处理效率低下，这些操作所花费的时间就会增加，从而导致网络延迟增大。

网络吞吐量是指单位时间内网络能够传输的数据量，协议栈对吞吐量的影响主要体现在其对数据处理能力和资源利用效率上。高效的协议栈能够快速地处理数据包，减少数据包在系统中的停留时间，从而提高网络的吞吐量。

可靠性是网络通信的重要保障，协议栈通过多种机制来确保数据传输的可靠性。以TCP协议为例，它通过序列号、确认号和重传机制来保证数据的完整性和顺序性。

三、Socket 调用优化策略

3.1 选择合适的 I/O 模型

在Socket编程中，选择合适的I/O模型是优化网络性能的关键。常见的I/O模型包括阻塞I/O、非阻塞I/O和I/O多路复用，它们各自具有不同的特点和适用场景。

阻塞I/O是最基本的I/O模型，也是默认的I/O模式。在阻塞I/O模型中，当应用程序调用recv、send等I/O函数时，线程会被阻塞，直到操作完成。这种模型的优点是简单直观，易于理解和实现，适用于并发连接较少、对实时性要求不高的场景。但在高并发场景下，阻塞I/O会导致大量线程被阻塞，资源利用率低下。

非阻塞I/O模型中，当应用程序调用I/O函数时，无论操作是否完成，函数都会立即返回。如果数据尚未准备好，函数会返回一个错误提示，应用程序可以继续执行其他任务，而不需要等待。非阻塞I/O适用于对实时性要求较高、I/O操作不频繁的场景。

I/O多路复用是一种高效的I/O模型，它允许一个线程同时监听多个I/O事件。通过使用select、poll、epoll等系统调用，程序可以阻塞在这些调用上，等待其中一个或多个I/O事件发生。I/O多路复用模型可以有效地减少线程的数量，提高资源利用率，适用于高并发、大量连接的场景，如Web服务器、游戏服务器等。

3.2 多线程与 Socket 编程

在Socket编程中，多线程技术的应用可以显著提升服务器的并发处理能力。当服务器需要同时处理多个客户端的连接请求时，单线程的Socket服务器会在处理一个客户端请求时阻塞，无法及时响应其他客户端的请求。而多线程Socket服务器可以为每个客户端连接创建一个独立的线程，每个线程负责处理一个客户端的通信任务，从而实现并发处理。

以下是一个简单的多线程Socket服务器核心示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>

#define PORT 12345
#define BUFFER_SIZE 1024

// 客户端处理函数，供线程调用
void *handle_client(void *arg) {
    int client_socket = *(int *)arg;
    free(arg); // 释放传递过来的客户端socket描述符内存
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read;
    // 循环读取客户端数据并回显
    while ((bytes_read = read(client_socket, buffer, BUFFER_SIZE)) > 0) {
        write(client_socket, buffer, bytes_read); // 数据回显
        memset(buffer, 0, BUFFER_SIZE); // 清空缓冲区
    }
    if (bytes_read < 0) {
        perror("read error");
    }
    close(client_socket); // 关闭客户端连接
    pthread_exit(NULL); // 线程退出
    return NULL;
}

int main() {
    int server_socket, *client_socket;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    pthread_t tid;
    // 1. 创建TCP Socket
    if ((server_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }
    // ... 绑定、监听等步骤
    // 循环接受客户端连接
    while (1) {
        // 5. 接受客户端连接，获取客户端socket描述符
        client_socket = malloc(sizeof(int));
        if ((*client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_addr_len)) < 0) {
            perror("accept failed");
            free(client_socket);
            continue;
        }
        // 6. 创建线程处理该客户端连接
        if (pthread_create(&tid, NULL, handle_client, (void *)client_socket) != 0) {
            perror("pthread create failed");
            close(*client_socket);
            free(client_socket);
        }
        // 分离线程，避免内存泄漏
        pthread_detach(tid);
    }
    close(server_socket);
    return 0;
}

然而，多线程编程也带来了一些问题，如线程安全和资源限制。线程池是一种有效的优化方案，它预先创建一定数量的工作线程，将接收到的连接请求分配给这些线程处理。线程池可以减少线程创建和销毁的开销，提高系统性能。

3.3 优化 Socket 选项

Socket选项是调整网络连接行为的关键，通过合理设置Socket选项，可以优化网络性能、提高可靠性。

（1）TCP_NODELAY：该选项用于禁用Nagle算法。Nagle算法是TCP协议中的一种拥塞控制机制，它会将小的数据包合并成一个较大的数据包后再发送。在一些实时性要求较高的应用中，这种合并会导致小数据传输的延迟。通过设置TCP_NODELAY选项为1，可以禁用Nagle算法，使得数据能够立即发送，从而减少延迟。

int optval = 1;
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));

（2）SO_REUSEADDR：SO_REUSEADDR选项允许在一个端口释放后，立即被其他Socket重用。在默认情况下，当一个Socket关闭后，操作系统会保留该端口一段时间（处于TIME_WAIT状态），这会导致在这段时间内，其他Socket无法绑定到该端口。通过设置SO_REUSEADDR选项为1，可以告诉操作系统允许立即重用处于TIME_WAIT状态的端口。

int optval = 1;
setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

（3）SO_KEEPALIVE：SO_KEEPALIVE选项用于设置TCP连接的保活机制。当通信双方长时间没有数据交互时，协议栈会向对方发送心跳消息，以探测连接是否仍然有效。

（4）SO_RCVBUF 和 SO_SNDBUF：这两个选项分别用于设置Socket接收缓冲区和发送缓冲区的大小。通过调整缓冲区的大小，可以在一定程度上优化网络传输的效率。

int recvbuf = 32 * 1024; // 设置接收缓冲区大小为32KB
int sndbuf = 32 * 1024; // 设置发送缓冲区大小为32KB
setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &recvbuf, sizeof(recvbuf));
setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));

四、内核协议栈调优实操

4.1 内核参数调整

在Linux系统中，内核参数对网络性能有着至关重要的影响。下面介绍一些重要的内核参数及其调整策略。

  1. tcp_rmem 和 tcp_wmem：这两个参数分别用于设置TCP接收缓冲区和发送缓冲区的大小。它们都是由三个值组成，分别表示最小值（min）、默认值（default）和最大值（max）。在高并发场景下，适当增大这些值可以提升服务器的并发处理能力和响应速度。调整方法是在/etc/sysctl.conf中添加：

    net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 16384 16777216

    然后执行 sudo sysctl -p。

  2. somaxconn：该参数用于设置socket监听队列的最大长度，即listen()函数中backlog参数的最大值。在高并发场景下，如果somaxconn设置过小，监听队列可能会溢出。可以将其增大：

    net.core.somaxconn = 65535

  3. tcp_max_syn_backlog：此参数定义了TCP半连接队列的最大长度。增大此值可以应对高并发连接请求或缓解SYN攻击的影响。

    net.ipv4.tcp_max_syn_backlog = 65536

  4. tcp_tw_reuse 和 tcp_fin_timeout：tcp_tw_reuse参数允许重用处于TIME_WAIT状态的socket，tcp_fin_timeout参数用于设置FIN_WAIT_2状态的超时时间。在高并发短连接场景下，设置它们有助于快速释放资源。

    net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30

4.2 缓冲区优化

接收和发送缓冲区的设置对于网络性能的提升至关重要。

  1. 接收缓冲区优化：如果接收缓冲区过小，当数据接收速度较快而应用程序读取数据的速度较慢时，缓冲区可能会迅速填满，导致数据丢失。合理增大接收缓冲区的大小，可以减少数据丢失的风险。可以根据网络带宽和数据流量的大小来动态调整。

  2. 发送缓冲区优化：如果发送缓冲区过小，应用程序可能会因为缓冲区满而无法及时发送数据，导致数据发送延迟。优化发送缓冲区的大小可以减少数据发送延迟，提高数据传输的实时性。需要结合应用程序的发送速率和网络的拥塞情况来调整。

4.3 拥塞控制算法选择

拥塞控制算法是TCP协议中用于避免网络拥塞的关键机制。

  1. Reno 算法：是早期广泛使用的算法，包含慢启动、拥塞避免、快重传和快恢复四个阶段。在网络环境相对稳定、带宽波动较小的场景下表现良好。

  2. Cubic 算法：是对Reno算法的改进，在拥塞避免阶段采用了三次函数来调整拥塞窗口的大小。它能够更快速地适应网络带宽的变化，在高带宽延迟积网络和无线网络环境中表现出色。

在Linux系统中，可以通过修改内核参数net.ipv4.tcp_congestion_control来选择拥塞控制算法。例如，设置为Cubic：

net.ipv4.tcp_congestion_control = cubic

五、案例实战：高并发 Web 服务器场景

在某大型电商平台的Web服务器优化项目中，该平台在促销活动期间会面临海量的并发请求。优化前，服务器采用默认的Socket调用和内核协议栈配置。压力测试显示，当并发用户数达到5000时，服务器平均响应时间从50毫秒飙升至500毫秒，并出现大量请求超时。

通过分析，发现问题在于：I/O模型使用阻塞I/O，高并发下线程阻塞严重；内核参数如tcp_rmem、tcp_wmem缓冲区过小；somaxconn设置过小导致监听队列易溢出。

优化措施如下：

  • Socket调用优化：将I/O模型从阻塞I/O改为I/O多路复用（epoll），并设置线程池大小为100。
  • Socket选项设置：启用TCP_NODELAY以减少延迟；设置SO_REUSEADDR允许端口重用。
  • 内核协议栈调优：
    • net.ipv4.tcp_rmem = 4096 87380 16777216
    • net.ipv4.tcp_wmem = 4096 16384 16777216
    • net.core.somaxconn = 65535
    • net.ipv4.tcp_tw_reuse = 1
    • net.ipv4.tcp_fin_timeout = 30

核心优化代码示例如下（使用epoll与线程池）：

#include <sys/epoll.h>
#include <pthread.h>

#define THREAD_POOL_SIZE 100
#define MAX_EVENTS 10000

// 线程池和工作函数（简略结构）
typedef struct {
    pthread_t threads[THREAD_POOL_SIZE];
    int epoll_fd;
} ThreadPool;

void *worker_thread(void *arg) {
    int epoll_fd = *(int*)arg;
    struct epoll_event events[MAX_EVENTS];
    while(1) {
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        // ... 处理事件（接受连接、读取数据、发送响应）
    }
    return NULL;
}

int main() {
    int server_fd, epoll_fd;
    struct sockaddr_in server_addr;
    int optval = 1;

    // 1. 创建Socket并设置选项
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
    setsockopt(server_fd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));

    // 2. 绑定和监听（内核参数somaxconn已调大）
    bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    listen(server_fd, 1024); // backlog，受限于somaxconn

    // 3. 创建epoll实例并添加服务器fd
    epoll_fd = epoll_create1(0);
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = server_fd;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev);

    // 4. 初始化线程池
    ThreadPool pool;
    for (int i = 0; i < THREAD_POOL_SIZE; ++i) {
        pthread_create(&pool.threads[i], NULL, worker_thread, (void*)&epoll_fd);
        pthread_detach(pool.threads[i]);
    }

    // 主线程阻塞等待
    while(1) sleep(1);
    // ... 清理资源
    return 0;
}

优化效果：再次进行压力测试，当并发用户数达到10000时，服务器平均响应时间稳定在100毫秒以内，系统吞吐量提升至每秒5000个请求以上，性能得到显著提升。

通过对Socket调用的精细打磨和对内核协议栈的深度调优，我们能够有效释放系统的网络潜能。这要求开发者不仅理解API的用法，更要洞察其背后的系统原理。希望本文提供的思路和实战案例能为你构建高性能网络应用提供有价值的参考。如果你对更多底层技术优化感兴趣，欢迎到 云栈社区 交流探讨。




上一篇：身家过亿的程序员为何再创业？ClawdBot创始人Peter Steinberger的故事
下一篇：C/C++字节对齐控制详解：使用#pragma pack与__attribute__优化内存布局
Socket, 网络编程, Linux内核, TCP／IP, 高并发

相关帖子
返回列表
高级模式
B Color Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

手机版|小黑屋|网站地图|云栈社区 ( 苏ICP备2022046150号-2 )

GMT+8, 2026-2-1 20:42 , Processed in 0.287410 second(s), 42 queries , Gzip On.

Powered by Discuz! X3.5

© 2025-2026 云栈社区.

快速回复 返回顶部 返回列表