2.7通过select、多进程、多线程实现一个并发服务器

Sinbia_Lurika2024-02-09 9:29

select

cpp 复制代码 
#include <myhead.h>
 
#define PORT 8888              //端口号
#define IP "192.168.250.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);   
 
 
	//设置端口号快速重用
	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);
 
				//将读取的信息，发送回去
				send(i, buf, sizeof(buf), 0); 
			}
		}
 
	}
	//6、关闭所有套接字
	close(sfd);               //关闭监听
	return 0;
}

多进程

cpp 复制代码 
#include <myhead.h>
 
#define PORT 8888              //端口号
#define IP "192.168.250.100"       //IP地址
 
 
//定义函数处理客户端信息
int deal_cli_msg(int newfd, struct sockaddr_in cin)
{
 
    //5、收发数据使用newfd完成通信
    char buf[128] = "";
    while(1)
    {
        //清空字符串
        bzero(buf, sizeof(buf));
        int res = recv(newfd, buf, sizeof(buf), 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);
 
        //将读取的信息，发送回去
        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);    
    //设置端口号快速重用
    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;
}

多线程

cpp 复制代码 
#include <myhead.h>
 
#define PORT 8888              //端口号
#define IP "192.168.250.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));
        int res = recv(newfd, buf, sizeof(buf), 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);
 
        //将读取的信息，发送回去
        send(newfd, buf, sizeof(buf), 0); 
    }
 
    close(newfd);             //关闭通信的套接字
    pthread_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);   
 
    //设置端口号快速重用
    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;
}
相关推荐
李昊哲小课8 分钟前
deepin 安装 zookeeper
大数据·运维·zookeeper·debian·hbase
真真-真真25 分钟前
WebXR
linux·运维·服务器
轩辰～1 小时前
网络协议入门
linux·服务器·开发语言·网络·arm开发·c++·网络协议
wanhengidc1 小时前
短视频运营行业该如何选择服务器？
运维·服务器
雨中rain2 小时前
Linux -- 从抢票逻辑理解线程互斥
linux·运维·c++
-KamMinG2 小时前
Centos7.9安装openldap+phpldapadmin+grafana配置LDAP登录最详细步骤 亲测100%能行
运维·grafana
Bessssss2 小时前
centos日志管理，xiao整理
linux·运维·centos
s_yellowfish2 小时前
Linux服务器pm2 运行chatgpt-on-wechat,搭建微信群ai机器人
linux·服务器·chatgpt
豆是浪个2 小时前
Linux(Centos 7.6)yum源配置
linux·运维·centos
vvw&2 小时前
如何在 Ubuntu 22.04 上安装 Ansible 教程
linux·运维·服务器·ubuntu·开源·ansible·devops
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10RAG 实践- Ollama+RagFlow 部署本地知识库