并发服务器

最新推荐文章于 2024-05-30 21:35:46 发布
最新推荐文章于 2024-05-30 21:35:46 发布
阅读量61 收藏
点赞数
分类专栏： 网络编程 文章标签： c语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43487317/article/details/129318707
版权

  1. 多进程方式

  1. 实现思路

每当accept一个连接，就会创建一个子进程来处理该连接并进行通信。

  1. 服务器

int main()
{
    int sock = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in ser;
    ser.sin_family = AF_INET;
    ser.sin_port = htons( 8899 );
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    if ( -1 == bind(sock,(struct sockaddr *)&ser,sizeof(ser) ) ){
        perror("bind error\n");
    }

    listen(sock,10);      
    printf("wait listen\n");
    
    int fd;
    while(1){
        struct sockaddr_in cli;
        int len = sizeof( cli );
        fd = accept(sock,(struct sockaddr *)&cli,&len);
        printf("new client connected\n");
        pid_t pid = fork();
        if(pid == 0)
        {
            break;
        }
    }

    //read/write
    while(1){
        char buf[20] = {0};
        read(fd, buf , 20);
        printf(" [%d] send %s \n",fd,buf);
        write(fd,"send successed",20);
    }
    close(sock);
}

  1. 客户端

int main()
{
    int sock = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in ser;
    ser.sin_family = AF_INET;
    ser.sin_port = htons( 8899 );
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    /*    int connect (int sockfd , const struct sockaddr *addr,socklen_t len);*/    
   if ( -1 == bind(sock,(struct sockaddr *)&ser,sizeof(ser) ) ){
        perror("bind error\n");
    }

    //write/read 循环写
    while(1)
    {
        sleep(1);
        write( sock , "HAVE A GOOD DAY!" ,20);
        char buf[20] = {0};
        read( sock , buf , 20); 
        printf("%s \n",buf);
    }
    
    close(sock);
}

  1. 多线程方式

  1. 实现思路

为每个新加入的客户端创建一个线程，在线程函数内执行自己的输入输出操作。

  1. 服务端

void * routine(void * arg)
{
    int fd  =(int)arg; 
    while(1){
        sleep(1);
        write(fd,"hello cli",9);
        char buf[20] = {0};
        read(fd,buf,sizeof(buf));
        printf("fd = %d , buf = %s \n",fd,buf);
    }
}
int main()
{
    int sock = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in ser;
    ser.sin_family = AF_INET;
    ser.sin_port = htons( 8899 );
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    int ret = bind(sock,(struct sockaddr *)&ser,sizeof(ser));
    if ( ret < 0){
        perror("bind error\n");
    }

    listen(sock,10);
    printf("wait listen\n");
    
    int fd;
    while(1){
        struct sockaddr_in cli;
        int len = sizeof( cli );
        int fd = accept(sock,(struct sockaddr *)&cli,&len);
        printf("new client connected\n");
        
        pthread_t tid;
        pthread_create( &tid ,NULL,routine,(void *)fd);
        //不能使用join，因为join会将主函数阻塞
        pthread_detach( tid );
    }
    close(sock);
}

  1. 客户端

int main()
{
    int sock = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in ser;
    ser.sin_family = AF_INET;
    ser.sin_port = htons( 8899 );
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    /*    int connect (int sockfd , const struct sockaddr *addr,socklen_t len);*/    
    int ret = connect( sock,(struct sockaddr *)&ser,sizeof(ser));
    if(ret < 0){
        perror("connect error\n");
        exit( -1 );
    }
    //read/write
    while(1)
    {
        char buf[10] = {0};
        
        read( sock , buf ,sizeof(buf));
        printf("receive:%s \n",buf); 
        
        write(sock,"hello cli",9);
    }
    
    close(sock);
}

  1. select方式

  1. 实现思路

select系统调用同时监视用多个文件句柄，程序会阻塞在select函数这里，当有一个或多个句柄发生变化时就会执行相应的操作，最大只能监视1024个客户端。

  1. select函数

  1. int select(   int nfds,fd_set *readfds, fd_set *writefds, fd_set *exceptfds,struct timeval *timeout);

int nfds                    描述符内最大值加1

fd_set *readfds            读            不需要时传NULL

fd_set *writefds           写            不需要时传NULL

fd_set *exceptfds         异常         不需要时传NULL

struct timeval *timeout    等待时间 ： 0为不等

>0等待几秒或几毫秒

NULL为死等

因为readfds、writefds、exceptfds不仅是输入也是输出，所以在select时需要注意当运行过后，值是否会改变，是否需要重新赋值

  1. 返回值

0 ：没有就位，且超时

-1：有错

 >0：有人准备好

  1. fd_set 是需要监测的fd的集合，包含很多个fd
  1. fd_set操作函数：

void FD_CLR (int fd，fd_set *set);    从集合里面移出

int FD_ISSET (int fd, fd_set *set);       是否在集合中

void FD_SET (int fd, fd_set *set);       放入集合

void FD_ZERO (fd_set *set);           清空集合

  1. 服务端

int main()
{
    int sock = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in ser;
    ser.sin_family = AF_INET;
    ser.sin_port = htons( 8899 );
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    int ret = bind(sock,(struct sockaddr *)&ser,sizeof(ser));
    if ( ret < 0){
        perror("bind error\n");
    }

    listen(sock,5);        //int listen(int sockfd,int backlog最大长度);
    printf("wait listen\n");

    int fd[5];            //存放连接到服务器的客户端的描述符
    int idx = -1;        //存放新连接的下标
    fd_set ofds;        //存放需要监测的描述符
    FD_SET( sock,&ofds);        //将客户端也放入ofds中监测，监测是否有人请求连接
    int max_fd = sock;        //存放最大描述符
    while(1){
        fd_set rfds = ofds;
        int ret = select(max_fd+1,&rfds,NULL,NULL,NULL);
        if ( ret == -1 ){
            perror("select error\n");
        }else {
            if (FD_ISSET(sock,&rfds)){        //有人请求连接
                idx++;
                struct sockaddr_in cli;    
                int len = sizeof( cli );    
                fd[idx] = accept(sock,(struct sockaddr *)&cli,&len);    //接受连接
                printf("connect success\n");
                FD_SET( fd[idx],&ofds);            //将新连接存入句柄中监测
                max_fd = (fd[idx] > max_fd)?fd[idx]:max_fd;    //检测最大描述符是否需要改变 
            }else{
                for(int i = 0; i <= idx;i++)            //检测每个已存入的连接是否发生变化
                {
                    char buf[20] = {0};
                    if( FD_ISSET(fd[i],&rfds)){
                        read( fd[i] , buf ,sizeof(buf));
                        printf("fd[ %d ] receive %s", fd[i] , buf );
                        write(fd[i],"send successed",20);
                    }
                }
            }    
        }
        
    }
    close(sock);
}

  1. 客户端

int main()
{
    int sock = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in ser;
    ser.sin_family = AF_INET;
    ser.sin_port = htons( 8899 );
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    int ret = connect( sock,(struct sockaddr *)&ser,sizeof(ser));
    if(ret < 0){
        perror("connect error\n");
        exit( -1 );
    }
    
    fd_set ofds;
    FD_SET(0,&ofds);        //键盘输入
    FD_SET(sock,&ofds);     //传输数据
    while(1){    
        //因为select中rfds不仅是输入也是输出，当执行完一次后rfdsd的值会改变，所以需要不断将初始值ofds赋给rfds   
        fd_set rfds = ofds;    
        
        int ret = select( sock+1,&rfds,NULL,NULL,NULL);
        if ( ret == -1 ){
            perror("select error\n");
        }else{
            char buf[20] = {0};
            if( FD_ISSET(sock,&rfds)){            //检测到有数据传入
                read( sock , buf ,sizeof(buf));
                printf("receive:%s \n",buf);        
            }
            if( FD_ISSET(0,&rfds)){                //检测到有键盘输入
                int ret  = read( 0 , buf ,sizeof(buf));    //标准输入
                write(sock,buf,ret);
            }
        }
    }
    
    close(sock);
}

  1. poll方式

  1. 实现思路

和select的本质是一样的，但没有最大文件描述符限制

  1. poll函数

  1. int poll(struct pollfd *fds, nfds_t nfds, int timeout);
  1. struct pollfd *fds

struct pollfd{

int fd;            //文件描述符

short events;     //监测事件

short revents;     //事件监测结果

};

events、revents：

POLLIN：普通或带外优先数据可读

POLLHUP：程序挂起

  1. nfds_t nfds                //需要监测的文件数量 
  1. int timeout                //毫秒级等待

0：立即返回

>0：等待xx毫秒

-1：阻塞等

  1. 服务端

#define SA struct sockaddr

int main()
{
    int sfd = socket(AF_INET,SOCK_STREAM,0);
    
    struct sockaddr_in s;
    s.sin_family = AF_INET;
    s.sin_port = htons(8899);
    s.sin_addr.s_addr = inet_addr("127.0.0.1");
    int len = sizeof(s);
    
    if( -1 == bind(sfd,(SA *)&s,len)){
        perror("bind error\n");
        return -1;
    }
    listen(sfd,10);
    printf("wait connect\n");

    struct pollfd p[10];
    p[0].fd = sfd;
    p[0].events = POLLIN;
    int num = 1;

    while(1){
        int ret = poll(p,10,-1);
        if(ret == 0){
            printf("timeout\n");
        }
        else if(ret == -1){
            perror("select error\n");
        }else{
            if(p[0].revents & POLLIN){
                printf("0x%x \n",p[0].revents);
                int cfd = accept(sfd,(SA *)&s,&len);
                p[num].fd = cfd;
                p[num].events = POLLIN | POLLHUP;
                printf("new client connected total %d\n",num);
                num++;
            }
            int i = 1;
            for( i = 1; i<num;i++){
                if(p[i].revents & POLLHUP){        //客户端关闭，关闭连接
                    close(p[i].fd);
                    p[i].fd = p[num].fd;
                    num--;
                    printf("a client left, rest %d connect \n",num-1);
                }else if(p[i].revents & POLLIN){    //客户端传来数据
                    char buf[100] = {0};
                    read(p[i].fd,buf,sizeof(buf));
                    printf("fd [%d] receive: %s \n",p[i].fd,buf);
                    write(p[i].fd,"write successed",20);
                }
            }
        }
    }
    close(sfd);
    return 0;
}

  1. 客户端

#define SA struct sockaddr

int main()
{
    int sfd = socket(AF_INET,SOCK_STREAM,0);
    
    struct sockaddr_in s;
    s.sin_family = AF_INET;
    s.sin_port = htons(8899);
    s.sin_addr.s_addr = inet_addr("127.0.0.1");
    int len = sizeof(s);
    
    if( -1 == connect(sfd,(SA *)&s,len)){
        perror("connect error\n");
        return -1;
    }
    printf("connect successed\n");

    struct pollfd p[2];
    p[0].fd = sfd;
    p[0].events = POLLIN | POLLHUP;
    p[1].fd = 0;
    p[1].events = POLLIN | POLLHUP;
    
    while(1){
        int ret = poll(p,2,-1);
        if(ret == 0){
            printf("timeout\n");
        }
        else if(ret == -1){
            perror("select error\n");
        }else{
            char buf[100] = {0}; 
            if(p[1].revents & POLLIN){
                read(0,buf,100);
                write(sfd,buf,strlen(buf));
            }
            if(p[0].revents & POLLHUP){
                printf("server shut down \n");
                close( p[0].fd );
                return 0;
            }else if(p[0].revents & POLLIN){
                memset(buf,100,0);
                read(sfd,buf,sizeof(buf));
                printf("%s \n",buf);
            }
        }
    }
    return 0;
}
嗯?呃哦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
1000并发的系统服务器配置,1000并发服务器配置
weixin_42318912的博客
08-10 2385
1000并发服务器配置 内容精选换一换多个用户同时通过ssh登录堡垒机管理下的任一服务器时，允许登录的帐号数有上限，当登录的帐号数超出上限值时，必须退出一个帐号才能再登录一个账号。该问题是由于并发数限制导致的。云堡垒机支持100、200、500、1000、2000、5000资产规格配置，不同规格云堡垒机的并发数配置有差异，不同的资产规格的配置差异请参见服务版本差异。建议您扩容简要介绍Erlang是...
500并发的服务器要求性能,500个并发服务器要什么配置
weixin_36168447的博客
08-06 1597
500个并发服务器要什么配置 内容精选换一换云堡垒机包含主机管理、权限控制、运维审计、安全合规等功能，具备全方位运维风险控制能力的统一运维管理与审计产品,支持主流浏览器随时随地远程运维来自：产品云联络中心支持多租形式，运维管理员可直接在云联络中心Portal上创建呼叫中心，该呼叫中心对应CTI上已经存在的实体呼叫中心，并为该呼叫中心添加资源，资源包括：语音座席数：允许同时签入的座席数，这些座席有处...
实现TCP并发服务器
weixin_47783699的博客
11-25 2450
详解实现TCP并发服务器两种方法:1、使用多进程实现TCP并发服务器2、使用多线程实现TCP并发服务器。
大并发服务器架构
侯彩桦
01-26 6057
一、服务器设计目标 1、高性能（High Preormance）：是指对大量的并发请求，能做出快速的响应，这就要求我们的服务器能够最大程度发挥机器的性能，使机器在满负荷的情况下，尽可能多的处理并发请求，并且能及时快速的做出响应。 2、高可用（High Availability）：指的是服务器能够7x24小时不间断的提供服务，如果服务器出现了故障，也能够快速的转换到备用机，让备用机工作起来，而不需要人工的干预。这叫failover故障转移。 3、伸缩性（Scalability）: 指的是服务器具有良好的
UDP并发服务器思路
code_peak
07-14 3332
UDP并发与TCP并发的区别 在TCP并发编程中，通常使用one loop per thread的并发模型，也就是使用多个线程，每个线程中都有一个epoll loop，无论是使用epoll还是poll或select，在观察有无数据就绪时，都是针对多个文件描述符。如果只有一个文件描述符，那么进程只要观察那一个文件描述符即可。 网络编程中，一个Socket对应一个文件描述符。在TCP的并发中，服务器在监听端口初始化一个socket套接字描述符，接受客户端后就与每个客户端的连接有一个不同的文件描述符，所以TCP并
Linux高并发服务器开发—项目实战
梅山
07-11 4003
本文主要介绍开发一个基本的高并发服务器需要用到哪些技术栈和技术实现，内容包括：1、unixI\O操作5中工作模式。2、http协议内容的介绍。3、http协议的工作流程。 4、有限状态机编程思想。5、线程池原理的介绍。6、EPOLL如何确保两个线程同时访问一个socket‘’...
多线程与并发服务器设计
侯彩桦
02-20 1773
第一种、循环式/迭代式服务器 每处理完一个请求就关闭连接，这种模式称为短连接。循环式服务器只能够使用短连接，而不能够使用长连接。如果是长连接，处理完一个请求，write完不关闭连接而是循环到read这里接受下一个请求。而整个程序是一个单线程的程序，如果另一个程序请求过来就不能接受请求了，只能处理一个程序。要想处理多个客户端只能够短连接。这种服务器不是真正意义上的并发服务器，decode、compute、encode 不能处理太长，如果太长就会影响其他连接的响应时间。这个程序是单线程的程序，不能利用多核
TCP并发服务器实现
本末实验室
07-11 2781
对于单核CPU，同一个时间点只能处理一个任务。使用分时复用的方法，可以让CPU在一个时间片段中处理多个任务，这就是多任务处理的基本思想。软件设计上，有多进程和多线程两种编程模型，实现服务器的并发。 多进程与多线程的区别：https://blog.csdn.net/baidu_35534327/article/details/53494961 思维导图 多进程并发 在多...
高并发服务器的限制有哪些,如何提高并发量
小杰312的博客
05-30 3434
高并发服务器的限制有哪些,如何提高并发量
【Linux网络编程】高并发服务器 socket+epoll封装 服务器/客户端举例
持续学习，持续进步！
06-29 3718
本文主要介绍高并发服务器设计，socke+epoll封装，以及相关代码示例说明
非常全面的高性能高并发服务器架构解决方案.doc
06-16
非常全面的高性能高并发服务器架构解决方案.doc
基于并发服务器几种实现方法(总结)
09-20
下面小编就为大家分享一篇基于并发服务器几种实现方法(总结)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
qt c++ 高并发服务器 源码
02-07
qt c++ 高并发服务器 源码 编译通过
数据结构——二叉树（C语言版）
2302_80657849的博客
05-30 597
二叉树是一种非线性的数据结构。二叉搜索树、堆、红黑树等高阶数据结构都是依托于二叉树的基础实现的，所以我们有必要好好研究一下“二叉树”这种数据结构。本文只介绍二叉树的基础及中等用法，笔者能力有限，欠妥当之处欢迎批评指正。
二叉排序树简单实现【C风格】
weixin_45690131的博客
05-30 180
利用二叉排序树对数据进行保存、搜索、删除
python爬虫数据可视化-10-where条件语句-模糊查询.ev4.rar
05-31
python爬虫数据可视化-10-where条件语句-模糊查询.ev4.rar
train.csv
最新发布
05-31
train
Golang(Gin框架)+websocket 实现的多人聊天室+代码+详细文档
05-31
Golang(Gin框架)+websocket 实现的多人聊天室+代码+详细文档
Linux高并发服务器
05-21
Linux高并发服务器是指能够处理大量用户请求的服务器，通常是基于Linux操作系统。在高并发场景下，服务器需要具备一定的性能和稳定性，能够快速响应请求并保证服务的可用性。 为了实现高并发，需要采用一些技术手段...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值