网络编程（六）TCP并发服务器

已于 2024-06-25 21:59:01 修改
阅读量722 收藏 6
点赞数 16
文章标签： 网络 服务器 linux
于 2024-06-17 15:56:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44254079/article/details/139732182
版权

文章目录

（一）概念

循环服务器：同一时刻只能处理一个客户端的请求。

并发服务器：可以同时处理多个客户端的请求 相互之间不影响。

并发和并行的区别：
并发：并发是指两个或多个事件在 同一时间间隔 发生，把任务在不同的时间点交给处理器进行处理。在同一时间点，任务并不会同时运行。
并行（多核CPU）：并行是指两个或者多个事件在 同一时刻同时 发生，把每一个任务分配给每一个处理器独立完成。在同一时间点，任务一定是同时运行。

（二）TCP并发服务器

方式1：使用多线程实现
方式2：使用多进程实现
方式3：使用多路IO复用

（三）使用多线程实现TCP并发服务器

1. 思路

主线程负责等待客户端连接（accept）；
一旦有客户端连接成功，就创建一个子线程，专门用来和该客户端通信

2. 注意点

  1. 使用多线程一定要注意线程间的同步和互斥问题

3. 代码实现

server.c

#include <my_head.h>

sem_t sem;

typedef struct _Msg{
    int acceptfd;
    struct sockaddr_in clientaddr;
}msg_t;

void *task_func(void *msg){
    pthread_detach(pthread_self());//标记为分离态
    msg_t client_msg=*(msg_t *)msg;
    sem_post(&sem);
    char buff[128]={0};
    int nbytes=0;
    while(1){
        printf("开始通信  acceptfd = %d\n", client_msg.acceptfd);
        if(-1 == (nbytes = recv(client_msg.acceptfd,buff,sizeof(buff),0))){
            //出错
            close(client_msg.acceptfd);
            pthread_exit(NULL);
        }else if(0 == nbytes){//recv接收到的是0
            //客户端断开
            close(client_msg.acceptfd);
            pthread_exit(NULL);
        }
        if(!strcmp(buff,"quit")){
            close(client_msg.acceptfd);
            pthread_exit(NULL);
        }
        //正常接收数据
        printf("线程[%ld]接收到数据[%s]\n",pthread_self(),buff);
        strcat(buff,"--zyx");
        if(-1 == send(client_msg.acceptfd,buff,sizeof(buff),0)){
            close(client_msg.acceptfd);
            pthread_exit(NULL);
        }
    }
}

int main(int argc, char const *argv[])
{
    if(3 != argc){
        printf("Usage:%s IPv4 port\n",argv[0]);
        exit(-1);
    }
   
    //创建套接字
    int sockfd=0;
    if(-1 == (sockfd = socket(AF_INET,SOCK_STREAM,0))){
        ERR_LOG("sock error");
    }
    //填充结构体
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_addr.s_addr=inet_addr(argv[1]);
    serveraddr.sin_port=htons(atoi(argv[2]));
    socklen_t serveraddrlen = sizeof(serveraddr);
    //绑定结构体信息
    if (-1 == bind(sockfd,(struct sockaddr *)&serveraddr,serveraddrlen)){
        ERR_LOG("bind error");
    }
    //设置为监听状态
    if(-1 == listen(sockfd, 5))
        ERR_LOG("listen error");

    //客户端结构体保存网络信息
    struct sockaddr_in clientaddr;
    socklen_t clientaddrlen = sizeof(clientaddr);
    
    msg_t msg;
    int acceptfd = 0;
    pthread_t tid=0; 
    //无名信号量
    sem_init(&sem,0,1);

    while(1){
        printf("已就绪，等待连接..\n");
        //主线程等待连接
        if (-1 == (acceptfd = accept(sockfd,(struct sockaddr *)&clientaddr,&clientaddrlen))){
            ERR_LOG("accept error");
        }
        printf("有客户端连接\n");
        //如果主线程连接到了客户端，就创建子线程用来与客户端通信
        sem_wait(&sem);
        msg.acceptfd = acceptfd;
        msg.clientaddr = clientaddr;
        if(0 != pthread_create(&tid,NULL,task_func, &msg)){
            perror("pthread_create error");
        }
    }
    close(sockfd);

    return 0;
}

client.c

#include <my_head.h>

int main(int argc, char const *argv[])
{
    if(3 != argc){
        printf("Usage:%s Ipv4 port\n",argv[0]);
        exit(-1);
    }
    //创建套接字
    int sockfd=0;
    if(-1 ==(sockfd = socket(AF_INET,SOCK_STREAM,0))){
        ERR_LOG("socket error");
    }
    //填充结构体
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_addr.s_addr=inet_addr(argv[1]);
    serveraddr.sin_port=htons(atoi(argv[2]));
    socklen_t serverlen = sizeof(serveraddr);
    //连接服务器
    if(-1 == connect(sockfd,(struct sockaddr *)&serveraddr,serverlen)){
        ERR_LOG("connect error");
    }
    printf("连接成功\n");
    char buff[128]={0};
    while(1){
        scanf("%s",buff);
        if(-1 == send(sockfd,buff,sizeof(buff),0)){
            ERR_LOG("send error");
        }
        printf("数据[%s]已发送\n",buff);
        if(!strcmp(buff,"quit")){
            break;
        }
        memset(buff,0,sizeof(buff));
        if(-1 == recv(sockfd,buff,sizeof(buff),0)){
            ERR_LOG("recv error");
        }
        printf("接收到数据[%s]\n",buff);
    }
    close(sockfd);
    return 0;
}

（四）使用多进程实现TCP并发服务器

1. 思路

父进程负责accept等待客户端连接；
一旦有客户端连接成功，就创建一个子进程，专门用来和该客户端通信

2. 注意点

多进程要注意子进程资源的回收问题，在服务器程序中如果不及时回收子进程资源，子进程会成为僵尸进程，浪费系统资源

3. 代码实现

#include <my_head.h>

//信号处理函数
void sig_fun(int signum){
    if(SIGCHLD == signum){
        wait(NULL);
    }
}

int main(int argc, char const *argv[])
{
    if(3 != argc){
        printf("Usage:%s IPv4 port\n",argv[0]);
        exit(-1);
    }
   
    //创建套接字
    int sockfd=0;
    if(-1 == (sockfd = socket(AF_INET,SOCK_STREAM,0))){
        ERR_LOG("sock error");
    }
    //填充结构体
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_addr.s_addr=inet_addr(argv[1]);
    serveraddr.sin_port=htons(atoi(argv[2]));
    socklen_t serveraddrlen = sizeof(serveraddr);
    //绑定结构体信息
    if (-1 == bind(sockfd,(struct sockaddr *)&serveraddr,serveraddrlen)){
        ERR_LOG("bind error");
    }
    //设置为监听状态
    if(-1 == listen(sockfd, 5))
        ERR_LOG("listen error");

    //客户端结构体保存网络信息
    struct sockaddr_in clientaddr;
    socklen_t clientaddrlen = sizeof(clientaddr);
    
    int acceptfd = 0;
    pid_t pid=0; 
    //捕捉SIGCHLD信号
    signal(SIGCHLD,sig_fun);
    while(1){
        printf("已就绪，等待连接..\n");
        //主线程等待连接
        if (-1 == (acceptfd = accept(sockfd,(struct sockaddr *)&clientaddr,&clientaddrlen))){
            ERR_LOG("accept error");
        }
        printf("有客户端连接\n");
        if(-1 == (pid=fork())){//出错
            ERR_LOG("fork error");
        }else if(0 == pid){//子进程
            //执行完fork之后，父进程和子进程都各自有一个acceptfd和一个sockfd
            close(sockfd);
            char buff[128]={0};
            int nbytes=0;
            while(1){
                printf("开始通信\n");
                if(-1 == (nbytes = recv(acceptfd,buff,sizeof(buff),0))){//出错
                    break;
                }else if(0 == nbytes){//recv接收到的是0,客户端断开
                    break;
                }
                if(!strcmp(buff,"quit")){
                    break;
                }
                //正常接收数据
                printf("进程[%d]接收到数据[%s]\n",getpid(),buff);
                strcat(buff,"--zyx");
                if(-1 == send(acceptfd,buff,sizeof(buff),0)){
                    break;
                }
            }
            //子进程退出
            close(acceptfd);
            exit(0);
        }else if(0 < pid){//父进程
            close(acceptfd);//关闭父进程acceptfd，回收文件描述符资源
        }
    }
    close(sockfd);
    return 0;
}

4. 关于子进程结束后的资源回收问题

方式1：父进程退出时，子进程都变成孤儿，被init回收资源 但是我们父进程的是服务器进程 不会退出
方式2：使用wait阻塞的方式回收 --不推荐用 因为又多了一个阻塞的函数
方式3：使用waitpid非阻塞方式回收 --不推荐用 因为需要轮询 占用CPU
方式4：比较好的处理方式是 子进程退出时给父进程发信号 父进程接到信号后再去回收子进程资源（可以通过捕捉SIGCHLD SIGUSR1 SIGUSR2）

（五）使用IO复用实现TCP并发服务器

1. 思路

TCP的服务器默认不支持并发，原因是两类阻塞的函数 accept 和 recv之间相互影响
也就是说，本质上就是因为 sockfd 和 acceptfd 两类文件描述符的缓冲区中没有内容
就会阻塞，而且多个阻塞之间相互影响。

使用IO复用来监视文件描述符，当sockfd就绪，就说明有新的客户端连接；acceptfd就绪，就说明有已连接的客户端发送数据。

2. 代码实现

#include <my_head.h>

int main(int argc, char const *argv[])
{
    if(3 != argc){
        printf("Usage:%s IPv4 port\n",argv[0]);
        exit(-1);
    }
    //创建套接字
    int sockfd=0;
    if(-1 == (sockfd = socket(AF_INET,SOCK_STREAM,0))){
        ERR_LOG("sock error");
    }
    //填充结构体
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_addr.s_addr=inet_addr(argv[1]);
    serveraddr.sin_port=htons(atoi(argv[2]));
    socklen_t serveraddrlen = sizeof(serveraddr);
    //绑定结构体信息
    if (-1 == bind(sockfd,(struct sockaddr *)&serveraddr,serveraddrlen)){
        ERR_LOG("bind error");
    }
    //设置为监听状态
    if(-1 == listen(sockfd, 5))
        ERR_LOG("listen error");
    
    int acceptfd = 0;
    pid_t pid=0; 
    
    //创建集合
    fd_set readfds;     //母本
    FD_ZERO(&readfds);  //清空母本
    fd_set tempfds;     //备份
    FD_ZERO(&tempfds);  //清空备份
    int max_fd=0;       //缓存最大的文件描述符
    
    //首先将sockfd添加到监听队列中
    FD_SET(sockfd,&readfds);
    max_fd = max_fd > sockfd ? max_fd : sockfd; //更新最大的文件描述符
    
    int ret=0;          //缓存就绪文件描述符的个数
    int i=0;            //遍历变量
    int nbytes=0;       //缓存接收到的数据字节数
    char buff[128]={0}; //缓存数据

    while(1){
        //将母本复制给temp，对所有文件描述符进行监听
        tempfds = readfds;
        //开始监听，没有文件描述符准备就绪时就阻塞
        if(-1 == (ret = select(max_fd+1,&tempfds,NULL,NULL,NULL))){
            ERR_LOG("select error");
        }
        //有fd准备就绪，遍历处理
        for(i = 3; i < max_fd+1 && ret != 0; i++){
            //判断i是否就绪
            if(FD_ISSET(i, &tempfds)){
                ret--;
                //判断就绪的i是否是sockfd，如果是说明有客户端连接
                if(sockfd == i){
                    if(-1 == (acceptfd = accept(i,NULL,NULL))){
                        ERR_LOG("accept error");
                    }
                    printf("客户端[%d]连接\n",acceptfd);
                    FD_SET(acceptfd, &readfds);//将新的acceptfd添加到集合中
                    max_fd = max_fd > acceptfd ? max_fd : acceptfd;//更新最大的文件描述符
                }else{//说明有已经连接的客户端发来数据了
                    if(-1 == (nbytes = recv(i,buff,sizeof(buff),0))){
                        ERR_LOG("recv error");
                    }else if(0 == nbytes){ //说明有客户端断开连接
                        printf("客户端[%d]断开链接\n",i);
                        FD_CLR(i, &readfds);//将其移除队列
                        close(i);//关闭其文件描述符
                        continue;//跳过本次for循环
                    }
                    if(!strcmp(buff,"quit")){ //说明有客户端退出
                        printf("客户端[%d]退出\n",i);
                        FD_CLR(i, &readfds);//将其移除队列
                        close(i);//关闭其文件描述符
                        continue;//跳过本次for循环
                    }
                    //正常接收数据
                    printf("接收到数据：[%s]\n",buff);
                    strcat(buff,"--zyx");
                    if(-1 == send(i,buff,sizeof(buff),0)){
                        ERR_LOG("send error");
                    }
                }
            }
        }
    }
    close(sockfd);
}
臻一
关注
  • 16
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C 语言网络编程 — 高并发 TCP 网络服务器
烟云的计算
03-09 1257
可见，I/O 多路复用模型大大增加了每个进程可以管理的 Socket 数量，直到操作系统 fd 最大数量限制为止，通常可以设置百万级别，即：单机单进程支持百万连接，epoll 是解决 C10K 的利器，很多开源软件用到了它。四次挥手是一个冗长的过程，由于网络环境的复杂性与 TCP 连接的可靠性相违背，所以在某些特殊的场景中会出现相应的问题。所以，实际上，close() 并不会马上断开 Socket Connection，在高性能网络服务器中，需要非常关注 TCP 连接的状态情况。
TCP之多线程
love、reading的博客
10-17 2638
多线程服务器是对多进程服务器的改进，由于多进程服务器在创建进程时要消耗较大的系统资源，所以用线程来取代进程，这样服务处理程序可以较快的创建。据统计，创建线程比创建进程要快 10100 倍，所以又把线程称为“轻量级”进程。线程与进程不同的是：一个进程内的所有线程共享相同的全局内存、全局变量等信息，这种机制又带来了同步问题。 我们在使用多线程并发服务器时，直接使用以上框架，我们仅仅修改clien...
Linux网络编程之多线程并发TCP连接
qq_53928256的博客
03-31 1100
当用户请求上传文件的服务时，由于用户是将一个文件分成多个数据包dataPack分别上传服务器，由于可能无法实现多个线程同时对一个连接描述符进行接收数据包，此处采用的处理是线程接收数据包的过程中，若客户端又发送了另一个数据包，则该线程继续为该客户端提供服务，直至客户端没有连续的数据包发送后，则将该客户端连接描述符从任务队列work_queue中清除。由于每个数据包均记录了数据包的内容所对应的文件，已经对应的内容从文件起始位置的偏移，所以即使由于时延导致数据包不能连续发送，仍不会破坏文件的上传。
TCP并发服务器多线程
最新发布
weixin_43399456的博客
07-22 389
传出参数，线程创建成功之后，会被设置一个合适的值。主线程先退出，子线程会被强制结束。不能使用该函数打印错误信息。验证线程直接共享全局变量。
TCP并发服务器（多进程与多线程）
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
02-20 2135
多线程及多进程版本的TCP并发服务器实现。
【网络篇】第九篇——多线程版的TCP网络程序
m0_58367586的博客
11-13 649
需要注意的是，虽然新线程能够直接访问主线程accept上来的文件描述符，但此时新线程并不知道它所服务的客户端对应的是哪一个文件描述符，因此主线程创建新线程后需要告诉新线程对应应该访问的文件描述符的值，也就是告诉每个新线程在服务客户端时，应该对哪一个套接字进行操作。此时无论有多少个客户端发来连接请求，在服务端都会创建出相应数量的新线程为对应客户端提供服务，而当客户端一个个退出后，为其提供服务的新线程也就会相继退出，最终就只剩下最初的主线程仍在等待新连接的到来。
socket编程：多线程建立一对多的tcp服务
wch0001的博客
08-18 5677
文章目录前言编程模式编程步骤一对一的TCP服务一对多的TCP服务 前言 因为编程需要，需要将tcp服务增加到软件中进行本地测试，所以开始学习socket编程，首先需要了解socket相关的知识。本文只摘录编程中最先需要了解的内容，详细请参考以下两个博客: https://blog.csdn.net/xiaoquantouer/article/details/58001960 https://www.cnblogs.com/helloworldcode/p/10610581.html sockets（套接字）
STM32 TCP并发服务器源码（可与多个客户端通信）
07-09
总之，这个STM32 TCP并发服务器源码项目是一个学习和实践网络通信、并发处理以及嵌入式系统开发的好材料。通过深入研究和理解源代码，你可以提升在这些领域的技能，并可能将其应用到其他类似的IoT或工业控制系统中。
tcp.rar_TCP服务器_windows 网络编程_windows网络编程
09-14
本资源“tcp.rar”包含了TCP服务器端和客户端的源代码，对于学习和理解Windows平台上的TCP网络编程具有很高的价值。 TCP服务器端是网络服务的核心部分，它负责监听客户端的连接请求，并在建立连接后处理客户端的...
TCP并发服务器模型-多线程TCP服务器
01-18
通过rt-thread提供的网络API，结合多线程技术，开发者能够构建出高效、稳定、可扩展的TCP并发服务器，满足各种嵌入式设备和物联网应用的需求。在不断优化和调试的过程中，我们能够进一步提升服务器的稳定性和响应...
网络编程项目：论文管理系统（基于tcp传输、并发服务器、sqlite数据库等）
04-14
网络编程项目：论文管理系统（基于tcp传输、并发服务器、sqlite数据库等） c语言开发 linux操作系统 项目描述：该项目是实现论文上传下载功能(通过使用)，并通过数据库创建表，留下记录。 服务端是使用并发服务器，...
TCP多线程通信
04-08
Linux下TCP协议，实现服务器与客户端的完全自由通信。
TCP网络通信（多线程客户端和服务器端）
11-22
比较牛逼的代码 ，多线程，服务器和客户端可以同时相互接受和发送数据。 另外还有详细的Linux 网络编程资料
Socket编程之TCP并发服务器
枸杞桑葚菊花茶的博客
03-05 1078
将要监视的文件描述符都放在这个表里，将这表交给一个函数 (select poll epoll)，这个函数默认也是。在调用select函数的整个循环过程中，select函数调用之后我们需要对就绪的文件描述符进行IO处理。为了节省空间我们用一个比特位的0和1来表示文件描述符的状态，用不同的比特位来表示不同的文件，如果已知就绪的文件描述符的个数，在遍历所有IO处理的过程中就可以减少遍历的个数，当监视的文件描述符中，有一个或多个准备就绪的时候，这个函数会返回，返回的时候会。
网络编程（二）TCP多线程服务器编程详解
weixin_42445051的博客
03-28 6406
注：这里多线程编程使用的是c++11标准里面的跨平台方法。 前面已经介绍了单线程服务器编程的一个例子，为了实现一个服务器能够并发响应多个客户端的请求，这里引入多线程的方法： 将原来的单线程服务器改造成多线程服务器只需要改动下面两个地方 1，因为listen()监听函数过后，服务器的ip与端口就会暴露在网络中，网络中连接的各个客户端就可以连接该服务器，而所有的连接请求都会存储在监听文件描述符对应的读缓冲区中，每执行一次accept，就会从该监听文件描述符对应的读缓冲区中读取一个连接，因此，如果是多线程服务器，
互联网编程之多线程/线程池TCP服务器端程序设计
笔记
07-01 1815
多线程TCP服务器（30分）：设计编写一个TCP服务器端程序，需使用多线程处理客户端的连接请求。客户端与服务器端之间的通信内容，以及服务器端的处理功能等可自由设计拓展，无特别限制和要求。线程池TCP服务器（30分）：设计编写一个TCP服务器端程序，需使用线程池处理客户端的连接请求。客户端与服务器端之间的通信内容，以及服务器端的处理功能等可自由设计拓展，无特别限制和要求，但应与第1项要求中的服务器功能一致，便于对比分析。
多线程TCP通信
linsa_pursuer的博客
10-11 1169
  一.客户端服务端，形成对话模式。 1.创建服务端用作读取客户端的每一行内容，   并且服务端把每一行内容传输客户端，形成对话模式。   package chat; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputSt...
网络编程——TCP协议
weixin_50720782的博客
05-17 39
网络编程之TCP协议
Qt实现简易的多线程TCP服务器（附源码）
z1zyy的博客
03-25 2579
1.首先我们搞清楚，这个类是负责干嘛的？这个类我们要继承QTcpServer，重写虚函数incomingConnetion2.这是头文件，如果有报错，注意看使用#pragma once没有，因为可能涉及到头文件重复包含Q_OBJECTpublic:private://重写虚函数private://用来保存连接进来的套接字，存到ComboBox中//再包含一个widget对象//widget.hQ_OBJECTpublic:~Widget();
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值