linux学习笔记（29）网络编程——服务器客户端 及多进程多线程服务器

原创 已于 2025-10-12 09:48:56 修改 · 270 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #服务器 #笔记 #网络

于 2025-10-12 09:43:05 首次发布
服务器代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
    int server_fd, client_fd;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
    printf("=== TCP服务器启动 ===\n");
    1. 创建Socket文件描述符
    //AF_INET = IPv4, SOCK_STREAM = TCP, 0 = 默认协议
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket创建失败");
        exit(EXIT_FAILURE);
    }
    printf("1. Socket创建成功\n");    
     2. 设置服务器地址
    address.sin_family = AF_INET;           // IPv4
    address.sin_addr.s_addr = INADDR_ANY;   // 监听所有网卡
    address.sin_port = htons(PORT);         // 端口号，htons转换字节序
     3. 绑定Socket到地址
    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        perror("绑定失败");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("2. 绑定端口 %d 成功\n", PORT);
     4. 开始监听连接
     5  等待连接队列的最大长度
    if (listen(server_fd, 5) < 0) {
        perror("监听失败");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("3. 开始监听，等待客户端连接...\n");
     5. 接受客户端连接没人连接则阻塞
    client_fd = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen);
    if (client_fd < 0) {
        perror("接受连接失败");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("4. 客户端连接成功！\n");
     6. 接收客户端数据  会阻塞
    int bytes_read = read(client_fd, buffer, BUFFER_SIZE - 1);
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';  // 添加字符串结束符
        printf("5. 收到客户端消息: %s\n", buffer);
    }
     7. 发送回复给客户端
    char* response = "你好客户端！我是服务器！";
    write(client_fd, response, strlen(response));
    printf("6. 已发送回复给客户端\n");
     8. 关闭连接
    close(client_fd);
    close(server_fd);
    printf("7. 连接关闭，服务器退出\n");
    return 0;
}

 

端口号
0~1024知名端口
1025~4096 保留端口
一般用大于4096的
 
客户端代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define SERVER_IP "127.0.0.1"  // 本地回环地址
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
    int sockfd;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE] = {0};
    printf("=== TCP客户端启动 ===\n");
    // 1. 创建Socket
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket创建失败");
        exit(EXIT_FAILURE);
    }
    printf("1. Socket创建成功\n");
    // 2. 设置服务器地址
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    // 将IP地址字符串转换为网络字节序
    if (inet_pton(AF_INET, SERVER_IP, &serv_addr.sin_addr) <= 0) {
        perror("IP地址转换失败");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    printf("2. 服务器地址设置: %s:%d\n", SERVER_IP, PORT);
    // 3. 连接服务器
    if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("连接服务器失败");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    printf("3. 连接服务器成功！\n");
    // 4. 发送数据到服务器
    char* message = "你好服务器！我是客户端！";
    write(sockfd, message, strlen(message));
    printf("4. 已发送消息: %s\n", message);
    // 5. 接收服务器回复
    int bytes_read = read(sockfd, buffer, BUFFER_SIZE - 1);
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        printf("5. 收到服务器回复: %s\n", buffer);
    }
    // 6. 关闭连接
    close(sockfd);
    printf("6. 连接关闭，客户端退出\n");
    return 0;
}

 

 
 
多进程并发
多进程并发让服务器可以同时服务多个客户端。
 

多进程服务器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/wait.h>
int main() {
    printf("=== 多进程服务器启动 ===\n");
    // 1. 创建"总机电话"
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    // 2. 设置电话号码
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);
    // 3. 绑定电话号码
    bind(server_fd, (struct sockaddr*)&address, sizeof(address));
    // 4. 开始等待来电
    listen(server_fd, 5);
    printf("服务器准备就绪，等待客户连接...\n");
    while (1) {  // 无限循环，持续服务
        printf("\n=== 等待新客户 ===\n");
        // 5. 接听电话（接待顾客）
        int client_fd = accept(server_fd, NULL, NULL);
        printf("有新客户连接！\n");
        // 6. 神奇的一步：创建子进程（分配服务员）
        pid_t pid = fork();
        if (pid == 0) {
            // 子进程区域（服务员的工作）
            printf("子进程 %d: 开始服务客户\n", getpid());
            // 关闭不需要的服务器socket（子进程不需要接听新电话）
            close(server_fd);
            // 与客户对话
            char buffer[1024] = {0};
            read(client_fd, buffer, sizeof(buffer));
            printf("子进程 %d: 收到客户消息: %s\n", getpid(), buffer);
            // 回复客户
            char reply[100];
            snprintf(reply, sizeof(reply), "你好！我是服务员%d", getpid());
            write(client_fd, reply, strlen(reply));
            printf("子进程 %d: 服务完成，退出\n", getpid());
            close(client_fd);
            exit(0);  // 子进程完成任务后退出
        }
        else {
            // 父进程区域（接待员的工作）
            printf("父进程: 已分配子进程 %d 服务客户\n", pid);
            close(client_fd);  // 父进程不需要与客户直接通话
        }
    }
    close(server_fd);
    return 0;
}
=== 多进程服务器启动 ===
服务器准备就绪，等待客户连接...

=== 等待新客户 ===
有新客户连接！
父进程: 已分配子进程 1234 服务客户
子进程 1234: 开始服务客户
子进程 1234: 收到客户消息: 你好服务器！我是客户5678
子进程 1234: 服务完成，退出

=== 等待新客户 ===
有新客户连接！
父进程: 已分配子进程 1235 服务客户
子进程 1235: 开始服务客户
子进程 1235: 收到客户消息: 你好服务器！我是客户5679
子进程 1235: 服务完成，退出

 

测试客户端（可以开多个终端测试）

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

int main() {
    printf("=== 客户端启动 ===\n");
    
    // 1. 创建电话
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
    // 2. 拨打服务器电话
    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);
    
    connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    printf("连接到服务器成功！\n");
    
    // 3. 发送消息
    char message[100];
    snprintf(message, sizeof(message), "你好服务器！我是客户%d", getpid());
    write(sockfd, message, strlen(message));
    printf("发送: %s\n", message);
    
    // 4. 接收回复
    char buffer[1024] = {0};
    read(sockfd, buffer, sizeof(buffer));
    printf("收到回复: %s\n", buffer);
    
    // 5. 保持连接一段时间，方便观察
    printf("等待5秒后退出...\n");
    sleep(5);
    
    close(sockfd);
    printf("客户端退出\n");
    return 0;
}
=== 客户端启动 ===
连接到服务器成功！
发送: 你好服务器！我是客户5678
收到回复: 你好！我是服务员1234
等待5秒后退出...
客户端退出

 

 
多线程并发

简单的多线程并发服务器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
// 线程参数结构
typedef struct {
    int client_fd;
} thread_arg_t;
// 线程处理函数
void* handle_client(void* arg) {
    thread_arg_t* targ = (thread_arg_t*)arg;
    int client_fd = targ->client_fd;
    // 处理客户端请求
    char buffer[100];
    read(client_fd, buffer, sizeof(buffer));
    printf("线程%lu: 收到: %s\n", pthread_self(), buffer);
    // 回复客户端
    char reply[100];
    snprintf(reply, sizeof(reply), "Hello from thread %lu", pthread_self());
    write(client_fd, reply, strlen(reply));
    close(client_fd);
    printf("线程%lu: 服务完成\n", pthread_self());
    free(targ);  // 释放线程参数内存
    return NULL;
}
int main() {
    printf("=== 多线程服务器 (端口: 8081) ===\n");    
    // 创建服务器socket
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    // 设置地址
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8081);
    bind(server_fd, (struct sockaddr*)&address, sizeof(address));
    listen(server_fd, 5);
    printf("等待客户端连接...\n");
    while (1) {
        // 接受客户端连接
        int client_fd = accept(server_fd, NULL, NULL);
        printf("新客户端连接\n");
        // 创建线程参数
        thread_arg_t* targ = malloc(sizeof(thread_arg_t));
        targ->client_fd = client_fd;
        // 创建新线程处理客户端
        pthread_t thread_id;
        pthread_create(&thread_id, NULL, handle_client, targ);
        pthread_detach(thread_id);  // 线程分离，自动回收资源
    }
    close(server_fd);
    return 0;
}
=== 多线程服务器 (端口: 8081) ===
等待客户端连接...
新客户端连接
线程140123456: 收到: Hello from client 5678
线程140123456: 服务完成
新客户端连接
线程140123789: 收到: Hello from client 5679
线程140123789: 服务完成

 

测试客户端（通用版）

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

int main(int argc, char* argv[]) {
    if (argc != 3) {
        printf("用法: %s <IP> <端口>\n", argv[0]);
        printf("示例: %s 127.0.0.1 8080\n", argv[0]);
        return 1;
    }
    
    printf("=== 客户端启动 ===\n");
    
    // 创建socket
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
    // 设置服务器地址
    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(atoi(argv[2]));
    inet_pton(AF_INET, argv[1], &serv_addr.sin_addr);
    
    // 连接服务器
    connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    printf("连接到服务器 %s:%s 成功！\n", argv[1], argv[2]);
    
    // 发送消息
    char message[100];
    snprintf(message, sizeof(message), "Hello from client %d", getpid());
    write(sockfd, message, strlen(message));
    printf("发送: %s\n", message);
    
    // 接收回复
    char buffer[100] = {0};
    read(sockfd, buffer, sizeof(buffer));
    printf("收到: %s\n", buffer);
    
    // 保持连接一段时间便于观察
    sleep(2);
    
    close(sockfd);
    printf("客户端退出\n");
    return 0;
}

 

 
特性
多进程
多线程
创建方式
fork()
pthread_create()
资源开销
大（独立内存空间）
小（共享内存空间）
数据共享
困难（需要IPC）
容易（共享全局变量）
稳定性
高（进程崩溃不影响其他）
低（线程崩溃影响整个进程）
通信成本
高（进程间通信复杂）
低（直接访问共享内存）
创建速度
慢
快
  • 用多进程当：需要高稳定性，任务相互独立
  • 用多线程当：需要高性能，任务间需要频繁通信

 

《TCP/IP 网络编程》第 10 章——多进程服务器端（学习笔记）
←_←
06-24 468
代码链接 第 10 章 多进程服务器端 现在开始学习构建实际网络服务所需的内容 10.1 进程概念及应用 10.1.1 两种类型的服务器端 10.1.2 并发服务端的实现方法 下面列出的是具有代表性的并发服务器端实现模型和方法 多进程服务器：通过创建多个进程提供服务 多路复用服务器：通过捆绑并统一管理 I/O 对象提供服务 多线程服务器：通过生成与客户端等量的线程提供服务 先讲解第一种方法：多进程服务器。这种方法不适合在 Windows 平台下。 10.1.3 理解进程 进程的定义：占用内存空间的正在运
学习笔记 Linux高性能服务器编程
jojozym的博客
05-10 3603
《Linux高性能服务器编程》 游双著 Linux高性能服务器编程IP协议详解IP服务特点无状态无连接不可靠IPv4头部结构IP路由IP路由表怎么更新IPv6TCP协议详解TCP服务的特点TCP头部结构TCP三次握手TCP状态转移过程TCP的复位（RST）报文段TCP交互数据流TCP成块数据流TCP超时重传TCP拥塞控制Linux网络编程API1.socket地址API1.1 主机字节序和网络字节序1.2 通用socket地址1.3 专用socket地址1.4 IP 地址转换函数2.socket基础AP.
《Linux多线程服务端编程》笔记——多线程服务器的适用场合和常用编程模型
yanchenzhi的博客
04-12 657
最近在进修muduo，于是配套陈硕（大神老师，直接开头指出，之后就不写引用参考了，有兴趣的直接搜就可以了）的书一个起来学习，真的是不怕知识多，就怕知识乱。之前很多都是用到什么学什么，最多看一下相关的东西。读过书之后才发现自己的知识体系不够系统，因此边读边把有用的部分记录在此。 前两章的东西是线程安全和线程同步，之前在我的博客里陆陆续续提到很多，所以不另外做笔记。这是第三章的东西，从设计的思想开始剖...
Linux 网络编程学习笔记——十五、进程池和线程池
BeZer0的学习笔记
03-30 1万+
在前面的章节中，我们是通过动态创建子进程（或子线程）来实现并发服务器的。这样做有如下缺点：本章将分析这两种“池”的细节，给出它们的通用实现，并分别用进程池和线程池来实现简单的并发服务器。进程池和线程池相似，所以这里我们只以进程池为例进行介绍。如没有特殊声明，下面对进程池的讨论完全适用于线程池。进程池是由服务器预先创建的一组子进程，这些子进程的数目在 3 ～ 10 个之间（典型情况）。比如 httpd 守护进程就是使用包含 7 个子进程的进程池来实现并发的。线程池中的线程数量应该和 CPU 数量差不多。进程池
Linux学习笔记——网络编程socket篇
m0_64432298的博客
09-05 1706
Socket 是一个编程接口 是一种特殊的文件描述符 (everything in Unix is a file) 并不仅限于TCP/IP协议 面向连接 (Transmission Control Protocol - TCP/IP) 无连接 (User Datagram Protocol -UDP 和 Inter-network Packet Exchange - IPX)
Linux系统编程学习笔记——并发服务器基础
qq_41007891的博客
08-14 148
前面学习流socket编程时，服务器每次只能处理一个客户端，这个访问完了之后再去处理下一个，而在上一节中，通过listen()函数建立一个访问队列，服务器挨个处理每个客户端的访问。这种服务器就叫迭代型服务器，为了同时处理多个客户端，就可以用并发型服务器。迭代型服务器：服务器每次只处理一个客户端，只有当完全处理完一个客户端的请求后才去处理下一个客户端。并发型服务器：这种类型的服务器能够同时处理多个客户端的请求。
【Linux网络编程学习】使用socket实现简单服务器——多进程&多线程版本
fjtooo的博客
11-14 2698
此为牛客Linux C++课程和黑马Linux系统编程笔记。 1. 思路 大体思路与上一篇的单进程版服务器–客户端类似，都是遵循下图： 多进程版本有以下几点需要注意： 由于TCP是点对点连接，服务器主进程连接了一个客户端以后就无法再与其他客户端相连，所以多进程版的服务器中的父进程只负责监听，连接并信息传输的工作交给子进程完成。每当accept到一个客户端的连接请求，就fork出一个子进程来处理。 父进程负责监听的同时，也要回收子进程的资源，避免产生僵尸进程。 2. 服务端 /*实现一个简单的多进程服务
Linux高性能服务器编程 | 读书笔记 | 6. 高性能服务器程序框架
m0_74795952的博客
12-17 1067
Linux 高性能服务器编程》一书中，把这一章节作为全书的核心，同时作为后续章节的总览。这也意味着我们在经历了前置知识的学习后，正式进入了 Web 服务器项目的核心部分的学习。
【Linux网络（C++)】——网络套接字（TCP/UDP编程模型）多进程，多线程，线程池服务器开发（画图解析）
sjp11的博客
02-22 5508
TCP/IP协议传输层的主要任务是向位于不同的（有时候位于同一主机）上的应用程序提供端到端的通信服务，为了区分应用程序，TCP和UDP引入了端口号的概念。 端口号 端口号（port）是传输层协议的内容 是一个2字节的16位整数。 端口号是用来表示进程的，告诉操作系统，当前的数据要交给哪一个进程处理 ip地址+端口号能够标识网络上一台主机上的一个进程。 一个端口号只能标识一个进程 在同一台机器上，进程的间的端口号都是不同的。 任何的网络服务与网络客户端，如果要进行正常的数据通信，必须使用..
Linux 网络编程学习笔记——九、I/O 复用
热门推荐
BeZer0的学习笔记
03-27 1万+
I/O 复用使得程序能同时监听多个文件描述符，这对提高程序的性能至关重要。需要指出的是，I/O 复用虽然能同时监听多个文件描述符，但它本身是阻塞的。并且当多个文件描述符同时就绪时，如果不采取额外的措施，程序就只能按顺序依次处理其中的每一个文件描述符，这使服务器程序看起来像是串行工作的。如果要实现并发，只能使用多进程或多线程等编程手段。Linux 下实现 I/O 复用的系统调用主要有 select 、poll 和 epoll。
Linux高性能服务器编程学习笔记——Linux网络编程基础API
weixin_41676930的博客
11-19 360
Linux网络编程基础APILinux网络编程基础APIsocket地址API主机字节序和网络字节序通用socket地址专用socket地址IP地址转换函数创建socket命名socket监听socket接受连接 Linux网络编程基础API socket地址API 主机字节序和网络字节序 现代CPU的累加器一次都能装载4字节，即一个整数。这4字节在内存中排列的顺序将影响它被累加器装载成的整数值。这就是字节序问题。字节序分为大端字节序和小端字节序。大端字节序是指一个整数的高位字节存储在内存的低地址处，低位字
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
3. 采用模拟 Proacto r的事件处理模式，利用线程池实现多线程机制，实现高并发通信，减少频繁创建和销毁线程带来的开销；（信号和互斥锁） 4. 主进程负责事件的读写，子线程负责业务逻辑——用有限状态机解析HTTP...
Linux网络编程笔记(修订版)
06-27
- **并发服务器之TCP服务器**：服务器可以使用多进程或多线程的方式来并发处理多个客户端请求。当新的连接请求到达时，服务器可以创建一个新的进程或线程来处理该请求，而主线程继续监听其他新的连接请求。 - **...
Linux -- 网络层
2301_79389054的博客
10-11 577
本文介绍了网络层的基本概念和IP协议相关内容。首先阐述了网络层的作用是解决不同主机间报文转发和路径选择问题。详细解析了IP协议格式，包括版本号、首部长度、服务类型、生存时间等关键字段。重点讲解了网段划分原理，解释了网络号和主机号的作用，并对比了传统的五类IP地址划分与CIDR无类别路由方案。此外还介绍了特殊IP地址、解决IP地址短缺的技术（动态分配、NAT、IPv6）、私有与公网IP划分。最后说明了路由表的工作原理和数据包转发过程，通过具体示例展示了路由选择机制。
探索Linux：开源世界的钥匙
2303_78660565的博客
10-08 1008
摘要：Linux作为开源操作系统，自1991年由Linus Torvalds开发以来，已发展为全球数千开发者维护的生态圈。其开源自由、稳定可靠、安全防护和跨平台兼容等特性，使其占据服务器市场90%份额，并广泛应用于云计算、嵌入式设备等领域。新手可从Ubuntu等友好发行版入门，通过虚拟机或双系统体验。Linux不仅是技术典范，更是开源协作精神的体现，为用户提供自由定制的高效系统选择。（149字）
Linux中的进程监控，top界面解析
m0_73892800的博客
10-10 630
umask，进程管理，查看进程状态符号总结大全比如S Ss I<等是什么意思，top命令查看进程，分别代表啥，以及在top命令的界面下操作的快捷键。
如何在 Linux_Ubuntu 上安装 Qt 5：详细教程
最新发布
qq_35803412的博客
10-11 628
摘要： 本文详细介绍了在 Ubuntu 系统上安装 Qt 5 的两种方法：通过 apt 安装基础版本或使用 Qt 官方安装器 自定义安装。教程涵盖环境准备、依赖项安装、环境变量配置，并演示如何通过 Qt Creator 或命令行创建和编译 Qt 项目。还提供了常见问题（如 qmake 缺失、Qt Creator 启动失败）的解决方案，帮助开发者快速搭建 Qt 5 开发环境。适合 Ubuntu 20.04/18.04 用户参考。
Linux5：Linux网络编程
weixin_51368966的博客
10-11 339
用来检测网络传输中差错的传输控制协议TCP专门负责对不同网络进行互联的互联网协议IP从此TCP/IP协议诞生1983年ARPAnet上停止使用NCP，互联网上的主机全部使用TCP/IP协议，TCP/IP协议成为Internet中的“世界语”。
在线Linux 练习平台 （二）
致力于大数据+AI 的应用创新。
10-10 209
它可以全屏体验，让你感觉就是在一台真的Linux上玩耍，同时还支持多种发行版，想体验不同系统的可以试试。地址： https://copy.sh/v86/?
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值