day36——TCP并发服务器

已于 2024-08-14 22:26:56 修改
阅读量196 收藏 2
点赞数 5
文章标签： tcp/ip 服务器 网络协议
于 2024-08-14 22:15:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69277585/article/details/141201591
版权

一、引入

1> 对于UDP通信而言，由于是面向无连接的通信，一个服务器可以服务多个客户端，处理多个客户端的消息

2> 对于TCP服务器而言，需要建立连接，服务器域客户端建立连接后，其他客户端就无法通信了

3> 如何做到一个TCP服务器能够跟多个客户端进行通信，此时我们引入了TCP并发服务器

4> 实现TCP并发服务器可以使用：多进程、多线程、IO多路复用

二、循环服务器

2.1 循环服务器模型

1、sfd = socket();               //创建用于连接的套接字文件描述符
2、bind();                        //为套接字绑定ip地址和端口号
3、listen();                      //将套接字设置成被动监听状态
4、while(1)
{
     newfd = accept();                 //阻塞等待客户端的连接
     
     recv();
     send();         //数据收发
     close(newfd);      
}
close(sfd);                //关闭套接字

2.2 循环服务器实现 

#include<myhead.h>
#define SER_PORT 6666          //服务器端口号
#define SER_IP "192.168.0.136"    //服务器ip地址


int main(int argc, const char *argv[])
{
    //1、创建套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    //参数1：表示ipv4的网络通信
    //参数2：表示使用的是TCP通信方式
    //参数3：表示默认使用一个协议
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("socket success, sfd = %d\n", sfd);        //3

    //将端口号快速重用
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))==-1)
    {
        perror("setsockopt error");
        return -1;
    }
    printf("端口号快速重用成功\n");

    //2、为套接字绑定ip地址和端口号
    //2.1 填充地址信息结构体
    struct sockaddr_in sin;       
    sin.sin_family = AF_INET;       //通信域
    sin.sin_port = htons(SER_PORT);    //端口号
    sin.sin_addr.s_addr = inet_addr(SER_IP);    //ip地址

    //2.2 绑定工作
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) == -1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");

    //3、将套接字设置成被动监听状态
    if(listen(sfd, 128)==-1)
    {
        perror("listen error");
        return -1;
    }
    printf("listen success\n");

    //4、阻塞等待客户端的连接请求
    //4.1 定义变量用于接收客户端的信息
    struct sockaddr_in cin;          //用于接收地址信息
    socklen_t addrlen = sizeof(cin);  //用于接收长度

    
    while(1)
    {

        //4.2 接收连接
        int newfd = accept(sfd, (struct sockaddr*)&cin, &addrlen) ;
        if(newfd == -1)
        {
            perror("accept error");
            return -1;
        }
        printf("[%s:%d]: 已成功连接一个客户端\n", \
                inet_ntoa(cin.sin_addr), ntohs(cin.sin_port));

        //5、数据收发
        char buf[128] = "";

        while(1)
        {
            //清空容器
            bzero(buf, sizeof(buf));

            //从客户端套接字中读取数据
            int res = recv(newfd, buf, sizeof(buf), 0);
            if(res == -1)
            {
                perror("read error");
                return -1;
            }else if(res == 0)
            {
                printf("客户端已经下线\n");
                close(newfd);             //关闭客户端套接字
                break;
            }

            //正常收到客户端发来的消息
            printf("[%s:%d] : %s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);

            //对收到的消息进行一顿操作
            //此处省略一万行代码
            strcat(buf, "*_*");

            //将消息回复给客户端
            if(send(newfd, buf, strlen(buf), 0) == -1)
            {
                perror("发送error");
                return -1;
            }
            printf("发送成功\n");
        }
    }

    //6、关闭监听
    close(sfd);

    return 0;
}

三、使用多进程完成TCP并发服务器

3.1 实现模型

//定义收尸函数
void handler(int signo)
{
    while(waitpid()>0);
}

signal(SIGCHLD, handler);               //将信号与信号处理函数绑定

1、sfd = socket();               //创建用于连接的套接字文件描述符
2、bind();                        //为套接字绑定ip地址和端口号
3、listen();                      //将套接字设置成被动监听状态
4、while(1)
{
     newfd = accept();                 //阻塞等待客户端的连接
     pid = fork();            //创建子进程用于处理客户端
     if(pid > 0)
     {
         close(newfd);            //关闭newfd     
     }else if(pid == 0)
     {
         close(sfd);             //关闭sfd
         recv();
         send();         //数据收发
         close(newfd);      
     }
}
close(sfd);                //关闭套接字

3.2 实现代码

#include<myhead.h>
#define SER_PORT 6666          //服务器端口号
#define SER_IP "192.168.0.136"    //服务器ip地址

//定义信号处理函数
void handler(int signo)
{
    if(signo == SIGCHLD)
    {
        while(waitpid(-1, NULL, WNOHANG) > 0);
    }
}

/****************************************主程序*****************************/
int main(int argc, const char *argv[])
{

    //将子进程退出时的SIGCHLD信号绑定到信号处理函数中
    if(signal(SIGCHLD, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }


    //1、创建套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    //参数1：表示ipv4的网络通信
    //参数2：表示使用的是TCP通信方式
    //参数3：表示默认使用一个协议
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("socket success, sfd = %d\n", sfd);        //3

    //将端口号快速重用
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))==-1)
    {
        perror("setsockopt error");
        return -1;
    }
    printf("端口号快速重用成功\n");

    //2、为套接字绑定ip地址和端口号
    //2.1 填充地址信息结构体
    struct sockaddr_in sin;       
    sin.sin_family = AF_INET;       //通信域
    sin.sin_port = htons(SER_PORT);    //端口号
    sin.sin_addr.s_addr = inet_addr(SER_IP);    //ip地址

    //2.2 绑定工作
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) == -1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");

    //3、将套接字设置成被动监听状态
    if(listen(sfd, 128)==-1)
    {
        perror("listen error");
        return -1;
    }
    printf("listen success\n");

    //4、阻塞等待客户端的连接请求
    //4.1 定义变量用于接收客户端的信息
    struct sockaddr_in cin;          //用于接收地址信息
    socklen_t addrlen = sizeof(cin);  //用于接收长度


    while(1)
    {
        //4.2 接收连接
        int newfd = accept(sfd, (struct sockaddr*)&cin, &addrlen) ;
        if(newfd == -1)
        {
            perror("accept error");
            return -1;
        }
        printf("[%s:%d:%d]: 已成功连接一个客户端\n", \
                inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd);


        pid_t pid = fork();           //创建一个子进程用于跟客户端通信

        if(pid>0)
        {
            //关闭newfd
            close(newfd);

        }else if(pid == 0)
        {
            //关闭sfd
            close(sfd);

            //5、数据收发
            char buf[128] = "";

            while(1)
            {
                //清空容器
                bzero(buf, sizeof(buf));

                //从客户端套接字中读取数据
                int res = recv(newfd, buf, sizeof(buf), 0);
                if(res == -1)
                {
                    perror("read error");
                    return -1;
                }else if(res == 0)
                {
                    printf("客户端已经下线\n");
                    close(newfd);             //关闭客户端套接字
                    break;
                }

                //正常收到客户端发来的消息
                printf("[%s:%d] : %s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);

                //对收到的消息进行一顿操作
                //此处省略一万行代码
                strcat(buf, "*_*");

                //将消息回复给客户端
                if(send(newfd, buf, strlen(buf), 0) == -1)
                {
                    perror("发送error");
                    return -1;
                }
                printf("发送成功\n");
            }
            //退出子进程
            exit(EXIT_SUCCESS);
        }

    }

    //6、关闭监听
    close(sfd);

    return 0;
}

四、使用多线程完成TCP并发服务器

实现原理：主线程主要完成accept接收客户端连接请求的阻塞，当客户端发来连接请求后，创建一个分支线程用于跟客户端进行通信

4.1 实现模型

4.2 实现代码

#include<myhead.h>
#define SER_PORT 6666          //服务器端口号
#define SER_IP "192.168.0.136"    //服务器ip地址

//定义用于数据传递的结构体类型
struct MsgInfo
{
    int newfd;       //套接字文件描述符
    struct sockaddr_in cin;        //客户端地址信息结构体
};


//定义线程体函数
void *deal_cli_msg(void *arg)
{
    //解析主线程传过来的数据
    int newfd = (*(struct MsgInfo*)arg).newfd;
    struct sockaddr_in cin = (*(struct MsgInfo*)arg).cin;

    //5、数据收发
    char buf[128] = "";

    while(1)
    {
        //清空容器
        bzero(buf, sizeof(buf));

        //从客户端套接字中读取数据
        int res = recv(newfd, buf, sizeof(buf), 0);
        if(res == -1)
        {
            perror("read error");
            return NULL;
        }else if(res == 0)
        {
            printf("客户端已经下线\n");
            close(newfd);             //关闭客户端套接字
            break;
        }

        //正常收到客户端发来的消息
        printf("[%s:%d] : %s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);

        //对收到的消息进行一顿操作
        //此处省略一万行代码
        strcat(buf, "*_*");

        //将消息回复给客户端
        if(send(newfd, buf, strlen(buf), 0) == -1)
        {
            perror("发送error");
            return NULL;
        }
        printf("发送成功\n");
    }

    //退出线程
    pthread_exit(NULL);

}



/******************************主程序*****************************/
int main(int argc, const char *argv[])
{
    //1、创建套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    //参数1：表示ipv4的网络通信
    //参数2：表示使用的是TCP通信方式
    //参数3：表示默认使用一个协议
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
    printf("socket success, sfd = %d\n", sfd);        //3

    //将端口号快速重用
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))==-1)
    {
        perror("setsockopt error");
        return -1;
    }
    printf("端口号快速重用成功\n");

    //2、为套接字绑定ip地址和端口号
    //2.1 填充地址信息结构体
    struct sockaddr_in sin;       
    sin.sin_family = AF_INET;       //通信域
    sin.sin_port = htons(SER_PORT);    //端口号
    sin.sin_addr.s_addr = inet_addr(SER_IP);    //ip地址

    //2.2 绑定工作
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) == -1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success\n");

    //3、将套接字设置成被动监听状态
    if(listen(sfd, 128)==-1)
    {
        perror("listen error");
        return -1;
    }
    printf("listen success\n");

    //4、阻塞等待客户端的连接请求
    //4.1 定义变量用于接收客户端的信息
    struct sockaddr_in cin;          //用于接收地址信息
    socklen_t addrlen = sizeof(cin);  //用于接收长度



    while(1)
    {
        //4.2 接收连接
        //accept在阻塞接收客户端连接请求时，会给当前的客户端预选一个最小的未分配的套接字文件描述符
        //如果后期有更小的产生，也不会更新当前文件描述符了
        //更小的文件描述符，用于后面的客户端连接使用
        int newfd = accept(sfd, (struct sockaddr*)&cin, &addrlen) ;
        if(newfd == -1)
        {
            perror("accept error");
            return -1;
        }
        printf("[%s:%d:%d]: 已成功连接一个客户端\n", \
                inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd);

        //定义结构体变量，用于数据传递给线程体
        struct MsgInfo buf = {newfd, cin};

        //创建用于通信的分支线程
        pthread_t tid = -1;
        if(pthread_create(&tid, NULL, deal_cli_msg, &buf) != 0)
        {
            printf("pthread_create error\n");
            return -1;
        }
        
        //主线程用于给分支线程收尸
        pthread_detach(tid);            //将线程设置成分离态

    }

    //6、关闭监听
    close(sfd);

    return 0;
}

初夏怡情
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1.16 第二章+第三章 TCP和UDP基础通信模型day2+TCP并发服务器day1
01-16
1.16 第二章+第三章 TCP和UDP基础通信模型day2+TCP并发服务器day1
Day6.zip Qt tcp客户端 服务器
11-15
这个“Day6.zip”文件包含了与使用Qt库创建TCP客户端和服务器相关的资源，这通常是进行网络通信的基础部分。下面我们将详细探讨Qt中的TCP客户端和服务器编程。 首先，让我们关注标签“qt”。Qt库提供了丰富的API，...
网络编程day4——TCP循环服务器模型与并发服务器模型
weixin_54481049的博客
05-07 1554
只有在当前客户的所有请求都完成后，服务器才能处理下一个客户的连接/服务请求。关键是在某个客户端产生通信套接字后，在recv/send部分用一个while循环，直到此客户端完全结束通讯任务，才会产生新的通信套接字继续通信。并发服务器的设计思想是服务器接受客户端的连接请求后创建子进程来为客户端服务。： 大规模的 Web 服务器（如 Apache）、数据库服务器、在线游戏服务器等，需要处理大量并发连接的应用。TCP服务器接受一个客户端的连接后开始处理，完成了客户的所有请求后断开连接。
学习记录——day32 TCP并发服务器
weixin_64918301的博客
08-14 262
【代码】学习记录——day32 TCP并发服务器。
网络编程(day4)——TCP并发服务器模型
qq_43921012的博客
04-23 257
【代码】网络编程(day4)——TCP并发服务器模型。
华清远见嵌入式学习day22——并发服务器
UemTuBXuR的博客
04-10 244
【1】poll 函数 引入poll的目的： 因为select最多只能监听1024个文件描述符； #include <poll.h> int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct time...
Day17——知识点总结
01-21
1. Map双边队列 1.1 什么是Map 程序开发大部分数据都是键值对形式的 MySQL JSON XML 类对象成员变量和存储的数据 从前端发送的数据也可以转成Map格式 ==> 一键生成 ==> 类对象 ==> 一键存储 ==> 数据库 ...
Day18——知识点总结
12-22
1. String类 1.1 比较方式要求 1.2 获取方法 int length();![字符串比较要求](img/字符串比较要求.png) 获取字符串长度 "" char charAt(int index); 获取String字符串中指定下标位置的char类型字符，如果index...
网络瘫痪幕后黑手：如何应对TCP/IP端口消耗？
m0_73609283的博客
08-20 221
TCP/IP 协议是互联网通信的基础，它的稳定性和可靠性使我们使用互联网的十分重要的一点。在网络运行过程中， TCP/IP 的连接问题中， TCP/IP 端口耗尽故障是较为常见的一种。所以通过深入了解 TCP/IP 连接的原理、掌握故障排除方法以及采取有效的预防措施，可以及时解决这些问题，确保网络的稳定运行和业务的连续性。分析网络流量：使用网络流量分析工具，查看是否有异常的连接请求或大量的并发连接。重启相关服务：如被占用了大量的端口，可以尝试重启该服务，以释放未使用的连接。
TCP/IP 协议及其协议号
细雨青峦的博客
08-12 889
tcp/ip 协议号 十进制 十六进制
strip 、objdump、objcopy 差异与区别
weixin_43269452的博客
08-15 489
1、获取一个二进制文件，file 看一下基本信息。2、看下文件中调试信息。
linux之网络子系统-tcpdump 原理
最新发布
z20230508的博客
08-20 559
libpcap(Packet Capture Library)，即数据包捕获函数库，是Unix/Linux平台下的网络数据包捕获函数库，独立于系统的用户层包捕获的API接口，为底层网络监测提供了一个可移植的框架。捕获各种数据包，例如：网络流量统计。过滤网络数据包，例如：过滤掉本地上的一些数据，类似防火墙。分析网络数据包，例如：分析网络协议，数据的采集。存储网络数据包，例如：保存捕获的数据以为将来进行分析。libpcap库在linux上的安装过程sudo make。
Windows和Linux系统查看设备IP的方法
chen_znn的博客
08-16 450
本文记录了在Windows和Linux系统查看设备IP的方法
Java TCP练习（2）
Aishangyuwen的博客
08-16 214
Java TCP练习（2）
tcpdump的使用
zhenshanren的博客
08-17 288
tcpdump是linux上的抓包工具,类似windows系统的wireshark,是最广泛使用的抓包工具。
【Leetcode:93. 复原 IP 地址 + dfs】
Coder_ljw的博客
08-20 597
【Leetcode:93. 复原 IP 地址 + dfs】有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。 给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中
Java TCP练习
Aishangyuwen的博客
08-15 647
Java TCP练习
Java TCP练习1
Aishangyuwen的博客
08-17 279
Java TCP练习1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值