当前位置： 首页 > news >正文

【网络编程】网络套接字和使用案例

news 来源：原创 2025/5/23 9:41:06

一、为什么大多数网络编程使用套接字

在网络编程中，套接字 (socket) 是最常用的接口，但并不是所有的底层通信都依赖于套接字。尽管如此，绝大多数网络应用（特别是在操作系统层面）都使用套接字进行通信，因为它提供了跨平台、统一的接口来处理网络连接。

套接字提供了一个抽象层，使得开发人员可以更方便地与网络协议进行交互，无论是基于 TCP 的连接，还是基于 UDP 的无连接通信。套接字通常用于：

  1. 客户端与服务器之间的通信（如 HTTP、FTP、SSH 等协议）。
  2. 多进程和多线程的通信（如进程间通信 IPC，使用 Unix 域套接字）。

通过套接字，可以直接操作 IP 地址、端口号、数据包等网络概念，进行数据的发送和接收，从而实现网络通信。

底层实现

尽管开发者使用套接字接口进行编程，实际上，底层的实现会有不同的协议栈（如 TCP/IP 协议栈）来管理数据传输。操作系统的网络子系统会通过网络协议栈来封装、路由数据，并确保数据包按照正确的协议进行处理和传输。

  1. TCP/IP 协议栈：通常，操作系统会根据传入的套接字调用，执行相应的协议栈处理。例如，socket() 调用创建的 TCP 套接字，会被映射到 TCP/IP 协议栈中的传输层。
  2. 网络接口卡 (NIC)：最终，数据会通过网络接口卡（如以太网卡、Wi-Fi）进行实际的物理传输。

套接字的抽象

套接字是对底层网络协议的抽象，它封装了很多底层的复杂性，允许应用程序集中精力处理数据的发送和接收，而不需要关心底层网络协议的实现细节。套接字抽象了多种通信模式，常见的有：

  • 流式套接字 (Stream Socket, TCP)：提供可靠、面向连接的数据传输，适用于大多数应用，如 HTTP。
  • 数据报套接字 (Datagram Socket, UDP)：提供不可靠、无连接的数据传输，适用于实时性要求高的应用，如视频流、DNS。
  • 原始套接字 (Raw Socket)：允许直接访问网络层，适用于需要实现自定义协议或网络工具的应用，如网络嗅探工具。

二、套接字的系统调用

在网络编程中，常见的几个系统调用用于创建和管理网络连接，下面是对这些系统调用的详细讲解：

1. socket

socket() 是用于创建一个套接字（socket）的系统调用，它是网络编程的基础。一个套接字是应用程序和网络之间的接口，用于通信。此调用会返回一个套接字描述符，后续的网络操作都需要通过该套接字。

示例：
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  • AF_INET: 表示使用 IPv4 协议。
  • SOCK_STREAM: 表示创建一个流式套接字（TCP）。
  • 0: 默认协议，通常可以为 0。

2. bind

bind() 用于将套接字与本地地址（IP 和端口）绑定。对于服务器端，通常会先调用 bind()，将套接字与某个端口绑定，以便接收来自客户端的连接。

示例：
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080);
server_addr.sin_addr.s_addr = INADDR_ANY;  // 接受任意本地地址

bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));

3. listen

listen() 用于将一个套接字设为被动监听状态，它告诉操作系统该套接字将用于接收连接请求。服务器端在调用 listen() 后，进入等待客户端连接的状态。

示例：
listen(sockfd, 5);
  • sockfd: 套接字描述符。
  • 5: 等待队列的大小，即允许的最大连接数。如果超过此数量，新的连接请求会被拒绝。

4. accept

accept() 用于从等待队列中获取一个已连接的客户端套接字。当有客户端连接时，accept() 会返回一个新的套接字描述符，这个描述符是用于与客户端通信的。

示例：
int new_sockfd = accept(sockfd, (struct sockaddr*)&client_addr, &client_len);
  • sockfd: 被动监听的套接字。
  • client_addr: 客户端的地址信息。
  • client_len: 地址信息的大小。

5. recv

recv() 用于从已连接的套接字中接收数据。它会从网络中读取数据，并将其存储到指定的缓冲区。

示例：
int len = recv(new_sockfd, buffer, sizeof(buffer), 0);
  • new_sockfd: 与客户端建立连接后的套接字。
  • buffer: 用于存储接收到数据的缓冲区。
  • sizeof(buffer): 缓冲区的大小。

6. send

send() 用于向套接字发送数据。它将缓冲区中的数据发送到已连接的对方。

示例：
int len = send(new_sockfd, buffer, strlen(buffer), 0);
  • new_sockfd: 与客户端建立连接后的套接字。
  • buffer: 要发送的数据。
  • strlen(buffer): 数据的长度。

7. close

close() 用于关闭一个套接字，释放相应的资源。当通信完成或出现错误时，通常会调用 close() 来关闭连接。

示例：
close(new_sockfd);
close(sockfd);

三、使用案例

下面是一个简单的 TCP 服务器-客户端的示例，展示了如何在服务器端和客户端之间使用这些套接字系统调用进行通信。这个示例包含了服务器端和客户端代码，服务器端使用 socket、bind、listen、accept、recv、send 和 close 系统调用，客户端则使用 socket、connect、send、recv 和 close。

服务器端代码 (server.c)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define MAX_CLIENTS 5

int main() {
    int sockfd, new_sockfd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[1024];
    int len;

    // 创建套接字
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Socket creation failed");
        exit(1);
    }

    // 设置服务器地址结构
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;  // 接受任何来自本地的连接
    server_addr.sin_port = htons(PORT);  // 设置端口

    // 绑定套接字
    if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("Bind failed");
        close(sockfd);
        exit(1);
    }

    // 监听连接请求
    if (listen(sockfd, MAX_CLIENTS) < 0) {
        perror("Listen failed");
        close(sockfd);
        exit(1);
    }

    printf("Server listening on port %d...\n", PORT);

    // 接受客户端连接
    if ((new_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_len)) < 0) {
        perror("Accept failed");
        close(sockfd);
        exit(1);
    }

    printf("Connection accepted from %s:%d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

    // 接收客户端消息并发送回应
    while ((len = recv(new_sockfd, buffer, sizeof(buffer), 0)) > 0) {
        buffer[len] = '\0';  // 确保接收到的数据是以 null 结尾的字符串
        printf("Received: %s\n", buffer);
        send(new_sockfd, "Message received", 16, 0);  // 回复客户端
    }

    if (len == 0) {
        printf("Client disconnected\n");
    } else if (len < 0) {
        perror("Receive failed");
    }

    // 关闭套接字
    close(new_sockfd);
    close(sockfd);
    return 0;
}

客户端代码 (client.c)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define SERVER_IP "127.0.0.1"

int main() {
    int sockfd;
    struct sockaddr_in server_addr;
    char buffer[1024];
    int len;

    // 创建套接字
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Socket creation failed");
        exit(1);
    }

    // 设置服务器地址结构
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);  // 设置端口
    if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
        perror("Invalid address");
        close(sockfd);
        exit(1);
    }

    // 连接到服务器
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("Connection failed");
        close(sockfd);
        exit(1);
    }

    printf("Connected to server\n");

    // 发送消息到服务器
    printf("Enter message: ");
    fgets(buffer, sizeof(buffer), stdin);
    send(sockfd, buffer, strlen(buffer), 0);

    // 接收服务器的回复
    len = recv(sockfd, buffer, sizeof(buffer), 0);
    if (len > 0) {
        buffer[len] = '\0';  // 确保接收到的数据是以 null 结尾的字符串
        printf("Server reply: %s\n", buffer);
    } else {
        perror("Receive failed");
    }

    // 关闭套接字
    close(sockfd);
    return 0;
}

解释

  • 服务器端：
    • 使用 socket() 创建一个套接字，bind() 将它绑定到指定的 IP 地址和端口，listen() 开始监听连接请求。
    • 通过 accept() 等待客户端连接，一旦连接成功，使用 recv() 接收客户端发送的数据，使用 send() 发送响应。
    • 一旦客户端断开连接或发生错误，服务器通过 close() 关闭套接字。
  • 客户端：
    • 使用 socket() 创建套接字，connect() 与服务器建立连接。
    • 客户端通过 send() 发送数据，接收服务器的回应使用 recv()。
    • 最后，使用 close() 关闭套接字。

如何运行

  1. 编译服务器端和客户端代码：

    gcc server.c -o server
gcc client.c -o client

  2. 先启动服务器：

    ./server

  3. 然后启动客户端：

    ./client

测试

在客户端运行时输入消息，例如“Hello, Server!”，服务器将接收到这个消息并发送一个确认消息“Message received”回来，客户端会显示这个消息。

通过这个简单的示例，你可以了解如何通过套接字进行基础的网络通信。

四、性能瓶颈

accept() 是一个阻塞函数，它用于从等待连接队列中接受一个客户端连接。如果没有客户端连接请求，accept() 会阻塞，直到有新的连接请求进来。这意味着，如果服务器仅有一个线程来处理连接请求，所有连接请求都会排队等待这个线程处理，这就限制了服务器的并发性。

recv() 是用于接收数据的函数，默认情况下它会阻塞，直到接收到数据。如果没有数据，recv() 会一直等待，这可能会导致服务器处理其他任务的能力下降。

问题

  • 阻塞： 如果没有连接请求，accept() 会阻塞，浪费 CPU 时间，因为它无法处理其他工作（比如接收数据）。
  • 低效： 仅用一个线程处理所有连接，会导致高并发场景下处理效率低下。

解决方案

  1. 多线程/多进程： 通过为每个连接创建一个新的线程或进程来处理，可以避免单线程处理大量连接带来的阻塞问题。这样，主线程只负责调用 accept() 来接受新连接，而子线程/进程处理具体的业务逻辑。此时可以引入线程池/进程池， 通过使用线程池或进程池，可以有效管理连接的处理，避免频繁创建和销毁线程/进程带来的开销。
  2. 异步 I/O（如 epoll）： 使用 Linux 中的 epoll 或其他平台的异步 I/O 模型，可以通过单一线程监听多个连接，实现高并发。在 epoll 模式下，accept() 不会阻塞，程序可以在同一个线程中处理多个连接。

相关文章：

  • 数学与计算生物学：生物系统的数学建模
  • vs code默认主题修改配置
  • 大白话JavaScript如何深拷贝一个对象或数组？JSON.parse (JSON.stringify ()) 这种方法有什么局限性？
  • ss命令——查看网络连接信息
  • vue+qrcode2批量生成二维码
  • 【Python爬虫(74)】用Python爬虫解锁法律条文数据的宝库
  • C语言 --- 经典习题1
  • 使用 C# 以api的形式调用 DeepSeek
  • 千峰React:案例一
  • IDEA 使用codeGPT+deepseek
  • 绕过【information_schema】，【order by】过滤
  • git 国内源
  • Mobaxterm服务器常用命令（持续更新）
  • 001 Kafka入门及安装
  • 【快速入门 LVGL】-- 1、STM32 工程移植 LVGL
  • IO 和 NIO 有什么区别？
  • 网页无法加载的常见原因及解决方法
  • 如果更换ip地址会怎么样？网络ip地址怎么更换
  • Spring 源码硬核解析系列专题（八）：Spring Security 的认证与授权源码解析
  • Unity3D 实现骨骼动画的 GPU Skinning 详解
  • 开封+网站建设+网络推广/南宁seo优化
  • 织梦网站栏目管理空白/seo网站推广方法
  • 合肥建设/郑州seo全网营销
  • 网站建设公司主营业务/百度怎么推广
  • 杭州做网站的公司有哪些/seo1现在怎么看不了
  • 胶州网站建设哪家好/沈阳网页建站模板