【无标题】分别通过select、多进程、多线程实现一个并发服务器

最新推荐文章于 2024-11-07 16:26:55 发布
最新推荐文章于 2024-11-07 16:26:55 发布
阅读量762 收藏 8
点赞数 8
文章标签： 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79915752/article/details/136069079
版权

select

#include<myhead.h>
 
#define PORT 8888              //端口号
#define IP "192.168.0.100"       //IP地址
 
 
int main(int argc, const char *argv[])
{
    //1、创建用于接受连接的套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
 
    printf("socket success sfd = %d\n", sfd);    //4
 
 
    //设置端口号快速重用
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
    {
        perror("setsockopt error");
        return -1;
    }
    printf("设置端口快速重用成功 _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
 
    //2、绑定IP地址和端口号
    //2.1、填充要绑定的地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family     = AF_INET;         //表明是ipv4
    sin.sin_port     = htons(PORT);        //端口号
    sin.sin_addr.s_addr = inet_addr(IP);     //IP地址
 
    //2.2、绑定
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
    //3、将套接字设置成被动监听状态
    if(listen(sfd, 128) == -1)
    {
        perror("listen error");
        return -1;
    }
 
    printf("listen success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
    //4、阻塞等待客户端连接请求，如果有新的客户端连接，则创建一个新的用于通信的套接字
    //4.1、定义客户端地址信息结构体
    struct sockaddr_in cin;             //客户端地址信息结构体
    cin.sin_family     = AF_INET;
    socklen_t socklen = sizeof(cin);          //客户端地址信息的大小
 
 
    定义一个用于检测文件描述符的集合
    fd_set readfds, tempfds;                          //在栈区定义
 
    清空容器中的内容
    FD_ZERO(&readfds);
    将要检测的文件描述符放入集合中
    FD_SET(sfd, &readfds);           //将sfd文件描述符放入
    FD_SET(0, &readfds);             //将0号文件描述符放入
 
 
    //定义一个容器
    char buf[128] = "";
    int res = 0;             //接收select的返回值
    int newfd = -1;          //存放用于最新连接客户端的套接字
    int maxfd = sfd;          //定义控制select函数中最大文件描述符
 
    struct sockaddr_in saveCin[1024];       //用于存放客户端地址信息结构体
 
 
    while(1)
    {
        将集合内容复制一份
        tempfds = readfds;
 
        使用select阻塞等待集合中的文件描述符有事件产生
        res = select(maxfd+1, &tempfds, NULL, NULL, NULL);
        if(res == -1)
        {
            perror("select error");
            return -1;
        }else if(res == 0)
        {
            printf("time out\n");
            return -1;
        }
 
 
        //遍历所有集合中文件描述符
        for(int i=0; i<=maxfd; i++)
        {
            //判断当前i是否在集合中，如果不在，直接判断下一个
            if(!FD_ISSET(i, &tempfds))
            {
                continue;
            }
 
            判断sfd是否还在集合中
            if( i == sfd)
            {
                //4.2、阻塞接收客户端的链接请求，并且获取客户端的地址信息
                newfd = accept(sfd, (struct sockaddr*)&cin, &socklen);
                if(newfd == -1)
                {
                    perror("accept error");
                    return -1;
                }
                printf("accept success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
                将newfd放入readfds中
                FD_SET(newfd , &readfds);
 
                //更新maxfd
                if(newfd > maxfd)
                {
                    maxfd = newfd;
                }
 
                //将最新的客户端套接字放入数组的下标为new的位置
                saveCin[newfd] = cin;
                printf("newfd = %d\n", newfd);
 
            }else if(i == 0 )    //判断是否是终端输入
 
            {
                char buf1[128] = "";
 
                bzero(buf, sizeof(buf));
                //从终端获取数据
                fgets(buf, sizeof(buf), stdin);       //从终端获取数据
                buf[strlen(buf)-1]='\0';
                printf("触发终端输入事件:%s\n", buf);
 
                sprintf(buf1, "%s%s", "系统消息：", buf);
 
                //将数据发送给所有客户端
                for(int j=4; j<=maxfd; j++)
                {
                    send(j, buf1,sizeof(buf1), 0);
                }
 
 
            }else
            {
                //5、收发数据使用newfd完成通信
                char buf[128] = "";
                //清空字符串
                bzero(buf, sizeof(buf));
                int ret = recv(i, buf, sizeof(buf), 0);        //从套接字中读取客户端发来的消息
 
                //判断收到的结果
                if(ret == 0)
                {
                    printf("客户端已经下线\n");    
                    close(i);             //关闭通信的套接字
 
                    将当前的文件描述符从集合中删除
                    FD_CLR(i, &readfds);
 
                    更新maxfd
                    for(int j=maxfd; j>=0; j--)
                    {
                        //判断当前的j是否在集合中，如果在，则为maxfd
                        if(FD_ISSET(j, &readfds))
                        {
                            maxfd = j;
                            break;
                        }
                    }
 
                    continue;           //继续判断下一个
                }else if(ret < 0)
                {
                    perror("recv error");
                    return -1;
                }
 
                printf("[%s:%d]：%s\n", inet_ntoa(saveCin[i].sin_addr), ntohs(saveCin[i].sin_port), buf);
 
                //将读取的信息，加上一些字符发送回去
                strcat(buf, "*_*");
                send(i, buf, sizeof(buf), 0); 
 
 
            }
        }
 
    }
 
    //6、关闭所有套接字
    close(sfd);               
    return 0;
}

多进程 

#include<myhead.h>
 
#define PORT 8888              //端口号
#define IP "192.168.0.100"       //IP地址
 
 
//定义函数处理客户端信息
int deal_cli_msg(int newfd, struct sockaddr_in cin)
{
 
    //5、收发数据使用newfd完成通信
    char buf[128] = "";
    while(1)
    {
        //清空字符串
        bzero(buf, sizeof(buf));
        //read(newfd, buf, sizeof(buf));        //从套接字中读取客户端发来的消息
        int res = recv(newfd, buf, sizeof(buf), 0);        //从套接字中读取客户端发来的消息
        //buf[strlen(buf)-1] = '\0';
 
        //判断收到的结果
        if(res == 0)
        {
            printf("客户端已经下线\n");
            break;
        }else if(res < 0)
        {
            perror("recv error");
            return -1;
        }
 
        printf("[%s:%d]：%s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);
 
        //将读取的信息，加上一些字符发送回去
        strcat(buf, "*_*");
        send(newfd, buf, sizeof(buf), 0); 
    }
 
    close(newfd);             //关闭通信的套接字
 
    return 0;
}
 
 
//定义信号处理函数
void handler(int signo)
{
    if(signo == SIGCHLD)
    {
        while(waitpid(-1, NULL, WNOHANG) > 0);       //非阻塞形式回收僵尸进程
    }
}
 
 
int main(int argc, const char *argv[])
{
    //1、创建用于接受连接的套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
 
    printf("socket success sfd = %d\n", sfd);    //4
 
 
    //设置端口号快速重用
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
    {
        perror("setsockopt error");
        return -1;
    }
    printf("设置端口快速重用成功 _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
    //2、绑定IP地址和端口号
    //2.1、填充要绑定的地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family     = AF_INET;         //表明是ipv4
    sin.sin_port     = htons(PORT);        //端口号
    sin.sin_addr.s_addr = inet_addr(IP);     //IP地址
 
    //2.2、绑定
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
    //3、将套接字设置成被动监听状态
    if(listen(sfd, 128) == -1)
    {
        perror("listen error");
        return -1;
    }
 
    printf("listen success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
    //4、阻塞等待客户端连接请求，如果有新的客户端连接，则创建一个新的用于通信的套接字
    //4.1、定义客户端地址信息结构体
    struct sockaddr_in cin;             //客户端地址信息结构体
    cin.sin_family     = AF_INET;
    socklen_t socklen = sizeof(cin);          //客户端地址信息的大小
 
    //定义子进程变量
    pid_t pid;
 
    //将SIGCHLD信号绑定到自定义信号处理函数中
    if(signal(SIGCHLD, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
 
    while(1)
    {    
        //4.2、阻塞接收客户端的链接请求，并且获取客户端的地址信息
        int newfd = accept(sfd, (struct sockaddr*)&cin, &socklen);
        if(newfd == -1)
        {
            perror("accept error");
            return -1;
        }
        printf("accept success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
        //创建子进程,让子进程完成通信
        pid = fork();
        if(pid > 0)
        {
            //关闭newfd，父进程不用
            close(newfd);
 
            
            
        }else if(pid == 0)
        {    
            //对于子进程而言，sfd是没有用的，需要关闭
            close(sfd);
 
            //调用处理客户端函数、
            deal_cli_msg(newfd, cin);
 
            //退出子进程
            exit(EXIT_SUCCESS);
            
        }else
        {
            perror("fork error");
            return -1;
        }
    }
 
    
 
    //6、关闭所有套接字
    close(sfd);               //关闭监听
 
    return 0;
}

多线程

#include<myhead.h>
 
#define PORT 8888              //端口号
#define IP "192.168.0.100"       //IP地址
 
//定义用于向线程体传参的结构体类型
struct msg_info
{
    int newfd;
    struct sockaddr_in cin;
};
 
 
//定义线程体函数
void *deal_cli_msg(void *arg)
{
    //获取主线程传递的信息
    int newfd = ((struct msg_info*)arg) -> newfd;
    struct sockaddr_in cin = ((struct msg_info*)arg) -> cin;
 
    //5、收发数据使用newfd完成通信
    char buf[128] = "";
    while(1)
    {
        //清空字符串
        bzero(buf, sizeof(buf));
        //read(newfd, buf, sizeof(buf));        //从套接字中读取客户端发来的消息
        int res = recv(newfd, buf, sizeof(buf), 0);        //从套接字中读取客户端发来的消息
        //buf[strlen(buf)-1] = '\0';
 
        //判断收到的结果
        if(res == 0)
        {
            printf("客户端已经下线\n");
            break;
        }else if(res < 0)
        {
            perror("recv error");
            return NULL;
        }
 
        printf("[%s:%d]：%s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);
 
        //将读取的信息，加上一些字符发送回去
        strcat(buf, "*_*");
        send(newfd, buf, sizeof(buf), 0); 
    }
 
    close(newfd);             //关闭通信的套接字
    ptread_exit(NULL);               //退出线程
 
 
}
 
int main(int argc, const char *argv[])
{
    //1、创建用于接受连接的套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd == -1)
    {
        perror("socket error");
        return -1;
    }
 
    printf("socket success sfd = %d\n", sfd);    //4
 
 
    //设置端口号快速重用
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
    {
        perror("setsockopt error");
        return -1;
    }
    printf("设置端口快速重用成功 _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
 
    //2、绑定IP地址和端口号
    //2.1、填充要绑定的地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family     = AF_INET;         //表明是ipv4
    sin.sin_port     = htons(PORT);        //端口号
    sin.sin_addr.s_addr = inet_addr(IP);     //IP地址
 
    //2.2、绑定
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))==-1)
    {
        perror("bind error");
        return -1;
    }
    printf("bind success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
    //3、将套接字设置成被动监听状态
    if(listen(sfd, 128) == -1)
    {
        perror("listen error");
        return -1;
    }
 
    printf("listen success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
    //4、阻塞等待客户端连接请求，如果有新的客户端连接，则创建一个新的用于通信的套接字
    //4.1、定义客户端地址信息结构体
    struct sockaddr_in cin;             //客户端地址信息结构体
    cin.sin_family     = AF_INET;
    socklen_t socklen = sizeof(cin);          //客户端地址信息的大小
 
    while(1)
    {
        //4.2、阻塞接收客户端的链接请求，并且获取客户端的地址信息
        int newfd = accept(sfd, (struct sockaddr*)&cin, &socklen);
        if(newfd == -1)
        {
            perror("accept error");
            return -1;
        }
        printf("accept success _%d_ %s_ %s_\n", __LINE__, __FILE__, __func__);
 
        //定义用于向线程体传参的结构体变量
        struct msg_info info = {newfd, cin};
 
        //创建分支线程用于通信
        pthread_t tid;
        if(pthread_create(&tid, NULL, deal_cli_msg, &info) != 0)
        {
            printf("分支线程创建失败\n");
            return -1;
        }
 
        //将该线程分离
        if(pthread_detach(tid) != 0)
        {
            printf("分离失败\n");
            return -1;
        }
 
    }
   
 
    //6、关闭所有套接字
    close(sfd);               //关闭监听
 
    return 0;
}

qjw.c
关注
多线程select并发
qq_42611237的博客
06-28 1269
父进程 　　负责监听，处理客户端的连接请求，也就是在父进程中循环调用 accept() 函数； 　　创建子进程：建立一个新的连接，就创建一个新的子进程，让这个子进程和对应的客户端通信； 　　回收子进程资源：子进程退出回收其内核 PCB 资源，防止出现僵尸进程。子进程 　　负责通信，基于父进程建立新连接之后得到的文件描述符，和对应的客户端完成数据的接收和发送； 　　与客户端建立链接； 　　收发数据：send() / write()，recv() / read()。1、创建线程： 注意，第三个参数是void *
多线程与并发服务器设计
侯彩桦
02-20 1880
第一种、循环式/迭代式服务器 每处理完一个请求就关闭连接，这种模式称为短连接。循环式服务器只能够使用短连接，而不能够使用长连接。如果是长连接，处理完一个请求，write完不关闭连接而是循环到read这里接受下一个请求。而整个程序是一个单线程的程序，如果另一个程序请求过来就不能接受请求了，只能处理一个程序。要想处理多个客户端只能够短连接。这种服务器不是真正意义上的并发服务器，decode、compute、encode 不能处理太长，如果太长就会影响其他连接的响应时间。这个程序是单线程的程序，不能利用多核
对PHP并发、多进程、多线程、异步处理、分布式系统的一些了解
ylnzzl的博客
07-26 2650
并发 基本概念 并发又被称为共行，是指同时段内处理多个任务。现代计算机系统能够在同一时段内以进程的形式，将多个程序加载到存储器中，由于CPU的时分复用（时间片轮转的抢占式调度方式），能让人产生多个任务在同一个CPU上同时执行的错觉。 注意并发是指逻辑上同时发生，而并行则是指物理上同时发生。 PHP并发模型 PHP并发模型可以分为多进程模式和多线程模式，具体使用的是哪一种，得看PHP使用的是哪个SAPI（服务器应用程序编程接口）。例如Apache中可能采用多进程模型，也可能采用多线程模型。 Ngi
select、poll、epoll、多线程实现并发请求处理
weixin_44477424的博客
04-08 4389
select、poll、epoll、多线程实现并发请求处理 这里写目录标题select、poll、epoll、多线程实现并发请求处理**解决方法1：**多线程**采用IO多路复用实现并发处理客户端请求****解决方法2：select**解决方法3：**poll**解决方法4：**epoll****select、poll、epoll的选择** 服务器与客户端建立连接需要使用到一些接口，包括但不限于socket、bind、listen、accept 一个简单的服务器网络程序如下： int listenfd,
进程、线程、协程、并发、并行、IO多路复用
Flag_ing的博客
05-16 1484
目录 一、什么是IO操作 二、进程、线程、协程 1、进程是资源分配的基本单位 2、线程是任务调度的基本单位 3、协程—由线程创建并全权负责的小弟 三、并行、并发及其与CPU内核数的关系 1、理解并行与并发的区别 2、进程、线程与CPU核数之间的关系 3、同一个进程里的线程可以并行执行吗（满足条件时可以） 四、IO多路复用 五、参考文（zi）献（liao） 我竟然妄想在小小的篇幅下把这四件事讲明白，离谱，但又不太离谱~ 在多线程、多进程、并行、并发这几个概念中，有很多知识点容易让..
网络编程(6)单进程多线程并发服务器实现
拙言的专栏
02-15 2166
相比前面的fork方式的多进程服务器，用线程方式，更轻量级。最少用fork时，需要将内存映像，描述符等都要从父进程复制到子进程中，会占用大量的资源而 多线程方式都在一个进程内，就无需占用这些资源，但同步也是个问题，而且一个线程挂了，可能会影响到进程中的其它线程。 多线程并发的原理就是 当accept 成功连接一个客户端后，把与这个客户端的交互丢到新线程去处理它。   服务端代码:
TCP并发服务器多线程和多进程方式以及几种IO模型
a8687216的博客
08-27 1376
应用程序可以在等待 I/O 完成的同时执行其他任务，需通过轮询（多次尝试）来检查 I/O 是否完成。信号驱动 I/O 模型中，应用程序发起 I/O 操作并继续执行其他任务，当数据准备好时，内核会通过信号通知应用程序。在异步 I/O 模型中，应用程序发起 I/O 操作并立即返回，I/O 操作由内核完成，操作完成后内核通过回调机制通知应用程序。在阻塞 I/O 模型中，当应用程序发起 I/O 操作时，整个进程会被阻塞，直到操作完成。在这个过程中，应用程序无法执行其他任务，必须等待 I/O 操作的完成。
多线程高并发这一篇就够了不用再去别家了
qq_40388552的博客
12-30 5840
  高伸缩性的并发编程是一种艺术，是成为高级程序员的必备知识点之一，最近总结了一下相关方面的知识。   借鉴过得博客有的我也不知道原文作业是谁 https://blog.csdn.net/qq_34337272/article/details/81072874 https://www.cnblogs.com/dolphin0520/p/3932921.html 一、线程 什么是线程？ 线程是进...
nginx 多进程 + io多路复用 实现高并发
Linuxhus的博客
01-22 2218
一、nginx 高并发原理 简单介绍：nginx 采用的是多进程（单线程） + io多路复用(epoll)模型 实现高并发 二、nginx 多进程 启动nginx 解析初始化配置文件后会 创建（fork）一个master进程 之后 这个进程会退出 master 进程会 变为孤儿进程 由init进程托管。（可以通过python 或php 启动后创建子进程,然后杀死父进程得见子进程会由init进程托管） 如下图可以看到nginx master 进程由init（ppid 为1 ）进程管理。 .
【Linux网络编程】TCP并发服务器的实现（IO多路复用select）
m0_65835264的博客
08-16 3140
TCP的服务器默认的就是一个循环服务器，原因是有两个阻塞 accept函数 和 recv函数之间会相互影响。本文是TCP并发服务器、客户端的实现以及实例的详细解释。使用了IO多路复用select函数进行TCP并发服务器的构建。希望博客对您有所帮助。 .........
多进程并发服务器实现
04-04
本示例将探讨如何在Linux环境下利用多进程并发技术实现一个聊天服务器。这个话题涵盖了Linux操作系统、多进程编程以及Socket套接字通信等多个核心知识点。 首先，我们要了解Linux操作系统。Linux是一种开源、免费的...
Python实现的服务器示例小结【单进程、多进程、多线程、非阻塞式】
09-19
### Python 实现的服务器示例小结：单进程、多进程、多线程、非阻塞式 在本文中，我们将深入探讨如何使用 Python 实现不同类型的服务器：单进程、多进程、多线程以及非阻塞式服务器。每种类型的服务器都有其独特的...
本项目包括利用多线程、select、poll以及epoll实现的并发处理连接请求
04-21
这两类都要使用到IO多路复用，O多路复用是指单个进程/线程就可以同时处理多个IO请求。有三个方式select、poll、epoll。 select：将文件描述符放入一个集合中，调用select时，将这个集合从用户空间拷贝到内核空间...
多线程实现并发TCP服务器..ppt
06-07
在多线程并发服务器中，每个连接可能对应一个独立的线程，从而实现对多个客户端请求的同时响应。 4. **Linux下的TCP并发服务器设计模式** - **多进程模式**： 当服务器接收到新的连接请求时，通过`fork()`创建...
tcp三次握手和四次挥手
qq_25096749的博客
11-06 374
三次握手与四次挥手
压力测试，探索服务器性能瓶颈
ceshiren_com的博客
11-07 578
全链路压力测试是指基于真实业务场景，通过模拟海量的用户请求，对整个后台服务进行压力测试，从而评估整个系统的性能水平。
浅谈串口服务器的作用
a876106354的博客
11-01 509
通过将串行通信转换为以太网通信，串口服务器使得远程访问串行设备成为可能，这对于远程监控和控制非常有用。：串口服务器可以扩展网络，使得原本只能通过短距离串行通信连接的设备能够通过长距离的网络连接。：它可以帮助将传统的串行设备集成到现代的网络环境中，使得这些设备能够与网络中的其他设备通信。：在工业自动化和物联网(IoT)领域，串口服务器可以用于收集来自传感器和其他串行设备的数据。：串口服务器可以提供网络级别的安全措施，如VPN、防火墙和加密，以保护数据传输的安全。
【linux学习2】linux基本命令行操作总结
最新发布
CRUSH8496052的博客
11-07 159
Linux命令总结
学Linux的第六天
weixin_73929563的博客
10-31 1134
groupadd参数 工作组名-g GID：指定新工作组的GID，默认值是已有的最大的GID加1-r： 建立一个系统组账号，与-g不同时使用时则分配一个1999的GID//添加一个组ID为2000,组名为group2的新组groupmod参数 工作组名-g GID——为用户组指定新的组标识号-n新用户组——将用户组的名字改为新名字修改用户组的名称和用户组的GID值将组group1的GID修改为3000,组名修改为group11。
并发服务器实现方法探索：从单进程到多进程多线程
"这篇文章主要介绍了基于并发服务器的几种实现方法，包括简单的单进程TCP服务器、多进程和多线程的实现，并提到了高级模块在实现并发服务器中的应用。" 在IT行业中，服务器并发处理能力是关键性能指标之一，特别是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值