linux平台上的TCP并发服务--多线程版本

已于 2024-06-22 15:42:01 修改
阅读量698 收藏 19
点赞数 12
文章标签： linux 算法 服务器
于 2024-05-11 12:14:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ga526424/article/details/138709205
版权

题目要求

服务端

  1. 基于TCP套接字编写服务器端程序代码，可以绑定从终端输入的IP地址和端口。
  2. 服务器程序可以显示每一个进程的进程号和当前并发执行的进程数量。
  3. 服务器程序可以根据客户机要求的服务时间确定进程的生存时间，并在收到连接请求时，新建一个子进程处理该连接请求，并根据客户端请求的服务时间进行延时处理。
  4. 服务器要清除因并发服务而产生的僵尸进程。

客户端

  1. 基于TCP套接字编写客户端程序代码，可以从终端输入服务器的IP地址和端口。
  2. 客户端程序可以从终端输入对服务器的服务时间要求，并将该要求发送给服务器。

    联调服务器和客户端，服务器每收到一个连接就新建一个子进程，在子进程中接收客户端的服务时间请求，根据所请求的时间进行延时，然后终止子进程。如：客户端请求服务10s，则服务器的子进程运行10s，然后结束。

程序设计思路

服务端设计思路

  1. 创建线程池结构体： 定义一个结构体 ThreadPool 用于管理线程池，包括线程数组、任务队列、队头、队尾、队列中任务数量以及互斥锁和条件变量。

  2. 任务处理函数： 编写一个任务处理函数 task_handler，该函数在一个循环中等待任务队列中的任务，处理任务，然后继续等待。

  3. 主函数：

    • 解析命令行参数：解析命令行输入的IP地址和端口号。
    • 初始化线程池：初始化线程池的互斥锁和条件变量，以及其他相关变量。
    • 创建线程：循环创建指定数量的线程，每个线程执行任务处理函数。
    • 创建服务器套接字：使用 socket 函数创建一个TCP套接字。
    • 绑定套接字：使用 bind 函数将套接字绑定到指定的IP地址和端口号。
    • 监听连接：使用 listen 函数开始监听传入的连接请求。
    • 循环接受连接：使用 accept 函数接受客户端的连接请求，并将客户端的套接字添加到任务队列中。
    • 处理连接：当有新的连接到达时，将客户端的套接字添加到任务队列中，并通知等待的线程处理任务。
    • 清理资源：关闭服务器套接字，释放线程池相关资源。

服务端代码

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

#define MAX_CLIENTS 10
#define THREAD_POOL_SIZE 5

// 定义线程池中的任务结构
typedef struct {
    int client_socket;
    int service_time;
} Task;

// 线程池结构体
typedef struct {
    pthread_t threads[THREAD_POOL_SIZE]; // 线程数组
    Task task_queue[MAX_CLIENTS]; // 任务队列
    int head; // 队头索引
    int tail; // 队尾索引
    int count; // 队列中任务数量
    pthread_mutex_t mutex; // 互斥锁
    pthread_cond_t cond; // 条件变量
} ThreadPool; // 线程池结构体类型定义


// 线程池全局变量
ThreadPool thread_pool;

// 任务处理函数
void *task_handler(void *arg) {
    while (1) {
        pthread_mutex_lock(&thread_pool.mutex);

        // 如果任务队列为空，则等待条件变量
        while (thread_pool.count == 0) {
            pthread_cond_wait(&thread_pool.cond, &thread_pool.mutex);
        }

        // 取出任务
        Task task = thread_pool.task_queue[thread_pool.head];
        thread_pool.head = (thread_pool.head + 1) % MAX_CLIENTS;
        thread_pool.count--;

        pthread_mutex_unlock(&thread_pool.mutex);

        // 处理任务
        printf("Thread %ld handling client\n", pthread_self());
        sleep(task.service_time);
        printf("Thread %ld done\n", pthread_self());
        close(task.client_socket);
    }

    return NULL;
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    char *ip = argv[1];
    int port = atoi(argv[2]);

    int server_socket, client_socket;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);

    // 创建线程池
    pthread_mutex_init(&thread_pool.mutex, NULL);
    pthread_cond_init(&thread_pool.cond, NULL);
    thread_pool.head = 0;
    thread_pool.tail = 0;
    thread_pool.count = 0;

    // 创建线程
    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_create(&thread_pool.threads[i], NULL, task_handler, NULL);
    }

    // 创建服务器套接字
     /*socket(domain, type, protocol): 创建套接字，返回套接字描述符。
    domain 参数指定地址家族（如 AF_INET 表示 IPv4），
    type 参数指定套接字类型（如 SOCK_STREAM 表示 TCP 套接字），
    protocol 参数指定协议（通常为 0，表示使用默认协议）。*/
    
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("Error creating socket");
        exit(EXIT_FAILURE);
    }

    // 绑定套接字
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(ip);
    server_addr.sin_port = htons(port);
      /*bind(sockfd, addr, addrlen): 将套接字绑定到地址。
    sockfd 是套接字描述符，addr 是要绑定的地址信息结构体，addrlen 是地址结构体的长度。*/
    
    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("Error binding socket");
        close(server_socket);
        exit(EXIT_FAILURE);
    }

    // 监听连接
     /*listen(sockfd, backlog): 开始监听传入的连接请求。
    sockfd 是套接字描述符，backlog 是等待连接队列的最大长度。*/
    
    if (listen(server_socket, MAX_CLIENTS) == -1) {
        perror("Error listening for connections");
        close(server_socket);
        exit(EXIT_FAILURE);
    }

    printf("Server listening on %s:%d\n", ip, port);

    while (1) {
        // 接受连接
          /*accept(sockfd, addr, addrlen): 接受传入的连接请求，并返回新的套接字描述符用于通信。
        sockfd 是监听套接字的描述符，addr 是用于存储客户端地址的缓冲区，addrlen 是缓冲区长度。*/
        
        client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_len);
        if (client_socket == -1) {
            perror("Error accepting connection");
            continue;
        }

        pthread_mutex_lock(&thread_pool.mutex);

        // 如果任务队列已满，则等待条件变量
        while (thread_pool.count == MAX_CLIENTS) {
            pthread_cond_wait(&thread_pool.cond, &thread_pool.mutex);
        }

        // 将任务添加到队列
        int service_time;
        
         /*recv(sockfd, buf, len, flags): 接收数据。
            sockfd 是套接字描述符，buf 是接收数据的缓冲区，len 是缓冲区长度，flags 是接收选项（通常为 0）。*/

        recv(client_socket, &service_time, sizeof(service_time), 0);
        thread_pool.task_queue[thread_pool.tail].client_socket = client_socket;
        thread_pool.task_queue[thread_pool.tail].service_time = service_time;
        thread_pool.tail = (thread_pool.tail + 1) % MAX_CLIENTS;
        thread_pool.count++;

        pthread_mutex_unlock(&thread_pool.mutex);
        pthread_cond_signal(&thread_pool.cond); // 通知等待的线程

        printf("Task added to thread pool\n");
    }

    close(server_socket);
    return 0;
}

客户端设计思路

  1. 解析命令行参数： 解析命令行输入的服务器IP地址、端口号和服务时间。

  2. 创建套接字： 使用 socket 函数创建一个TCP套接字。

  3. 连接服务器： 使用 connect 函数连接到指定的服务器IP地址和端口号。

  4. 发送服务时间请求： 使用 send 函数将客户端请求的服务时间发送给服务器。

  5. 关闭套接字： 客户端发送完请求后，关闭套接字并退出程序。

 客户端代码


#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 != 4) {
        printf("Usage: %s <IP> <port> <service_time>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    char *ip = argv[1];
    int port = atoi(argv[2]);
    int service_time = atoi(argv[3]);

    int client_socket;
    struct sockaddr_in server_addr;

    // Create socket
    client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket == -1) {
        perror("Error creating socket");
        exit(EXIT_FAILURE);
    }

    // Connect to server
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(ip);
    server_addr.sin_port = htons(port);
    if (connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("Error connecting to server");
        close(client_socket);
        exit(EXIT_FAILURE);
    }

    // Send service time request to server
    send(client_socket, &service_time, sizeof(service_time), 0);

    printf("Service requested for %d seconds\n", service_time);

    close(client_socket);
    return 0;
}

 编译运行方法

编译为可执行文件：

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

启动服务器：

./server <IP> <port>

启动客户端：

./client <IP> <port> <service_time>

其中，<IP>为服务器的IP地址，<port>为服务器的端口号，<service_time>为服务时间要求。

运行结果截图

8f1fc6a07b9c45fd933ceeb4f00e1032.png07e3fd7cc6a34c439e53b5178f42ad8e.png

c35c26bbb882424184e628bd25cb6cde.png

可以看到服务端可以同时处理客户端的请求。

 

 

@小糕糕
关注
linux平台上的TCP并发服务
cczxsong的博客
04-25 2381
实验一：linux平台上的TCP并发服务（4学时） 题目 掌握基本套接字函数使用方法、TCP协议工作原理、并发服务原理和编程方法。实验内容：在linux平台上实现1个TCP并发服务器，至少可以为10个客户端同时提供服务。 （1） 基于TCP套接字编写服务器端程序代码，然后编译和调试； （2） 服务器程序要达到：可以绑定从终端输入的IP地址和端口；可以显示每一个进程的进程号；可以显示当前并发...
Linux多线程高并发服务器
03-10
在IT行业中，Linux多线程高并发服务器设计是构建高性能网络服务的核心技术之一。这种设计模式主要用于处理大量的并发连接请求，充分利用系统资源，提供高效稳定的服务。以下将详细阐述相关知识点： 1. **多线程**：...
TCP并发服务器模型-多线程TCP服务器
01-18
rt-thread 操作系统下TCP并发服务器，及多线程TCP服务器
TCP并发服务器多线程
weixin_43399456的博客
07-22 424
传出参数，线程创建成功之后，会被设置一个合适的值。主线程先退出，子线程会被强制结束。不能使用该函数打印错误信息。验证线程直接共享全局变量。
Linux TCP多线程服务器
最新发布
R_conqueror的博客
08-25 1086
假设两个核心1，2，4个任务a,b,c,d，ab分配给了核心1，cd分配给了核心2，此时ab就是并发，cd也是并发，a与c就可以并行，b与d也可以并行。假如进程是一个文档编辑器，存放着相应的程序和文档，现在用户用键盘敲下回车，交互的程序接收键盘的按下事件，布局的程序将文字重新排布渲染出来，另外每隔一段时间，写入的程序保存文档到硬盘中，所以这三个程序最好能并行执行，但他们又需要访问修改同一个文档，所以肯定是在同一个进程中，所以现在需要更轻量级的3个线程，交互线程， 渲染线程，保存线程。
网络编程 TCP并发服务器模型 多进程 多线程
weixin_60354809的博客
10-24 793
同时处理多个客户端的请求（父进程或主线程负责连接；子进程或分支线程负责交互。
多线程并发服务器（TCP）
cxy255256的博客
08-19 4344
服务器客户端结果。
TCP并发服务器（多线程）
augeksjsj的博客
01-05 669
每连接一个客户端都创建一个子线程去处理信息，线程设置成分离态，线程结束系统自动回收资源。线程处理函数中不能使用exit函数。./可执行程序名 +IP地址+端口号。
ftp.rar_ftp_ftp 代码_linux tcp transfer_tcp传输文件_基于TCP-IP多线程文件传输
07-14
总的来说，实现基于TCP/IP的FTP文件传输程序是一个涉及网络协议、socket编程、多线程以及文件I/O等多个方面的综合性任务。这个过程可以帮助我们更好地理解网络通信的本质，并提升在Linux环境下开发网络应用程序的...
Linux-select-TCP.rar_C++并发编程_LINUX TCP _TCP客户端_linux C++ TCP_并发
09-24
总之，Linux环境下的C++ TCP并发编程涉及了套接字编程、`select()`函数的使用、线程管理和并发控制等多个核心概念。熟练掌握这些技术，将有助于你构建高效、稳定的网络应用程序。在实际项目中，还可以考虑使用更高级...
TCp.rar_Linux服务端_TCP客户端_linux tcp 客户端_socks_tcp 多线程
09-20
通过这个压缩包提供的示例，开发者可以学习如何在Linux环境下编写TCP客户端程序，理解多线程在并发连接中的作用，以及如何实现与不同服务端的自由连接。同时，了解Socks协议的应用，可以帮助开发者在需要时增强网络...
TCP并发服务器-采用windows多线程，WINSOCK
06-20
实现TCP连接并发，采用WINDOWS多线程
基于多线程的TCP并发服务器
weixin_38251305的博客
01-18 1315
多线程的TCP并发服务器的实现步骤：1，创建一个socket套接字2，绑定IP地址和端口信息到socket,使用函数bind() 1)IP地址 2）bind3，设置允许的最大连接数，使用函数listen()4,等待来自客户端的连接请求，使用函数accept()5，收发数据，用函数recv()，send()/sendto()或者read(),write() 6，关闭网络连接，close 开始：建...
TCP多进程、多线程并发服务器
weixin_47976606的博客
07-07 204
【代码】TCP多进程、多线程并发服务器。
tcp多进程多线程并发服务器
m0_49415349的博客
02-15 165
signal socket setsockopt bind listen accept fork close pthread_create pthread_detach
Linux网络编程之多线程并发TCP连接
qq_53928256的博客
03-31 1123
当用户请求上传文件的服务时，由于用户是将一个文件分成多个数据包dataPack分别上传服务器，由于可能无法实现多个线程同时对一个连接描述符进行接收数据包，此处采用的处理是线程接收数据包的过程中，若客户端又发送了另一个数据包，则该线程继续为该客户端提供服务，直至客户端没有连续的数据包发送后，则将该客户端连接描述符从任务队列work_queue中清除。由于每个数据包均记录了数据包的内容所对应的文件，已经对应的内容从文件起始位置的偏移，所以即使由于时延导致数据包不能连续发送，仍不会破坏文件的上传。
基于LinuxC语言实现的TCP多线程/进程服务器
m0_72847002的博客
08-30 1098
【代码】基于LinuxC语言实现的TCP多线程/进程服务器。
网络编程：C语言实现TCP并发服务器（多进程、多线程）
SYF_wdnmd的博客
05-18 2018
在多线程TCP服务器中，服务器进程会创建多个线程来处理客户端连接请求。对于每个客户端连接请求，服务器进程会创建一个新的线程去处理，各个线程之间相互独立，能够同时处理多个客户端连接请求。在多进程TCP服务器中，服务器进程会创建多个子进程来处理客户端连接请求。对于每个客户端连接请求，服务器进程会创建一个新的子进程去处理，各个子进程之间相互独立，能够同时处理多个客户端连接请求。在一个TCP并发服务器中，服务器进程通常会创建多个子进程或子线程来处理客户端连接请求，从而实现并发处理。2.多线程TCP服务器。
Linux环境下TCP并发服务器实现指南
资源摘要信息:"linux下TCP并发服务器实现及客户端通讯概述" 在Linux操作系统下开发网络应用程序时，TCP协议是一种常用的面向连接的、可靠的传输层通信协议。本文将详细介绍如何在Linux环境下使用C语言实现一个基于...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值