devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：菜鸟追梦旅行 | 2024-02-12 08:40:58

赞

踩

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

select

  1. #include<myhead.h>
  2.  
  3. #define PORT 8888              //端口号
  4. #define IP "192.168.114.109"       //IP地址
  5.  
  6.  
  7. int main(int argc, const char *argv[])
  8. {
  9. 	//1、创建用于接受连接的套接字
  10. 	int sfd = socket(AF_INET, SOCK_STREAM, 0);
  11. 	if(sfd == -1)
  12. 	{
  13. 		perror("socket error");
  14. 		return -1;
  15. 	}
  16.  
  17. 	printf("socket success\n"); 
  18.  
  19.  
  20. 	//设置端口号快速重用
  21. 	int reuse = 1;
  22. 	if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
  23. 	{
  24. 		perror("setsockopt error");
  25. 		return -1;
  26. 	}
  27. 	printf("设置端口快速重用成功\n");
  28.  
  29.  
  30. 	//绑定IP地址和端口号
  31. 	//填充要绑定的地址信息结构体
  32. 	struct sockaddr_in sin;
  33. 	sin.sin_family 	= AF_INET;         //表明是ipv4
  34. 	sin.sin_port 	= htons(PORT);        //端口号
  35. 	sin.sin_addr.s_addr = inet_addr(IP);     //IP地址
  36.  
  37. 	//绑定
  38. 	if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))==-1)
  39. 	{
  40. 		perror("bind error");
  41. 		return -1;
  42. 	}
  43. 	printf("bind success\n");
  44.  
  45. 	//套接字设置成被动监听状态
  46. 	if(listen(sfd, 128) == -1)
  47. 	{
  48. 		perror("listen error");
  49. 		return -1;
  50. 	}
  51.  
  52. 	printf("listen success\n");
  53.  
  54. 	//阻塞等待客户端连接请求，如果有新的客户端连接，则创建一个新的用于通信的套接字
  55. 	//定义客户端地址信息结构体
  56. 	struct sockaddr_in cin;             //客户端地址信息结构体
  57. 	cin.sin_family 	= AF_INET;
  58. 	socklen_t socklen = sizeof(cin);          //客户端地址信息的大小
  59.  
  60.  
  61. 	定义一个用于检测文件描述符的集合
  62. 	fd_set readfds, tempfds;                          //在栈区定义
  63.  
  64. 	清空容器中的内容
  65. 	FD_ZERO(&readfds);
  66. 	将要检测的文件描述符放入集合中
  67. 	FD_SET(sfd, &readfds);           //将sfd文件描述符放入
  68. 	FD_SET(0, &readfds);             //将0号文件描述符放入
  69.  
  70.  
  71.  
  72. 	//定义一个容器
  73. 	char buf[128] = "";
  74. 	int res = 0;             //接收select的返回值
  75. 	int newfd = -1;          //存放用于最新连接客户端的套接字
  76. 	int maxfd = sfd;          //定义控制select函数中最大文件描述符
  77.  
  78. 	struct sockaddr_in saveCin[1024];       //用于存放客户端地址信息结构体
  79.  
  80.  
  81. 	while(1)
  82. 	{
  83. 		将集合内容复制一份
  84. 		tempfds = readfds;
  85.  
  86. 		使用select阻塞等待集合中的文件描述符有事件产生
  87. 		res = select(maxfd+1, &tempfds, NULL, NULL, NULL);
  88. 		if(res == -1)
  89. 		{
  90. 			perror("select error");
  91. 			return -1;
  92. 		}else if(res == 0)
  93. 		{
  94. 			printf("time out\n");
  95. 			return -1;
  96. 		}
  97.  
  98.  
  99. 		//遍历所有集合中文件描述符
  100. 		for(int i=0; i<=maxfd; i++)
  101. 		{
  102. 			//判断当前i是否在集合中，如果不在，直接判断下一个
  103. 			if(!FD_ISSET(i, &tempfds))
  104. 			{
  105. 				continue;
  106. 			}
  107.  
  108. 			判断sfd是否还在集合中
  109. 			if( i == sfd)
  110. 			{
  111. 				//阻塞接收客户端的链接请求，并且获取客户端的地址信息
  112. 				newfd = accept(sfd, (struct sockaddr*)&cin, &socklen);
  113. 				if(newfd == -1)
  114. 				{
  115. 					perror("accept error");
  116. 					return -1;
  117. 				}
  118. 				printf("accept success\n");
  119.  
  120. 				将newfd放入readfds中
  121. 				FD_SET(newfd , &readfds);
  122.  
  123. 				//更新maxfd
  124. 				if(newfd > maxfd)
  125. 				{
  126. 					maxfd = newfd;
  127. 				}
  128.  
  129. 				//将最新的客户端套接字放入数组的下标为new的位置
  130. 				saveCin[newfd] = cin;
  131.  
  132. 			}else if(i == 0 )	//判断是否是终端输入
  133.  
  134. 			{
  135. 				char buf1[128] = "";
  136.  
  137. 				bzero(buf, sizeof(buf));
  138. 				//从终端获取数据
  139. 				fgets(buf, sizeof(buf), stdin);       //从终端获取数据
  140. 				buf[strlen(buf)-1]='\0';
  141. 				printf("触发终端输入事件:%s\n", buf);
  142.  
  143. 				sprintf(buf1, "%s%s", "系统消息：", buf);
  144.  
  145. 				//将数据发送给所有客户端
  146. 				for(int j=4; j<=maxfd; j++)
  147. 				{
  148. 					send(j, buf1,sizeof(buf1), 0);
  149. 				}
  150.  
  151.  
  152. 			}else
  153. 			{
  154. 				//收发数据使用newfd完成通信
  155. 				char buf[128] = "";
  156. 				//清空字符串
  157. 				bzero(buf, sizeof(buf));
  158. 				int ret = recv(i, buf, sizeof(buf), 0);   //从套接字中读取客户端发来的消息
  159.  
  160. 				//判断收到的结果
  161. 				if(ret == 0)
  162. 				{
  163. 					printf("客户端已经下线\n");	
  164. 					close(i);             //关闭通信的套接字
  165.  
  166. 					将当前的文件描述符从集合中删除
  167. 					FD_CLR(i, &readfds);
  168.  
  169. 					更新maxfd
  170. 					for(int j=maxfd; j>=0; j--)
  171. 					{
  172. 						//判断当前的j是否在集合中，如果在，则为maxfd
  173. 						if(FD_ISSET(j, &readfds))
  174. 						{
  175. 							maxfd = j;
  176. 							continue;           //继续判断下一个
  177. 						}
  178. 					}
  179.  
  180.  
  181. 				}else if(ret < 0)
  182. 				{
  183. 					perror("recv error");
  184. 					return -1;
  185. 				}
  186.  
  187. 				printf("[%s:%d]：%s\n", inet_ntoa(saveCin[i].sin_addr), ntohs(saveCin[i].sin_port), buf);
  188.  
  189. 				//将读取的信息，加上一些字符发送回去
  190. 				strcat(buf, "*_*");
  191. 				send(i, buf, sizeof(buf), 0); 
  192.  
  193.  
  194. 			}
  195. 		}
  196.  
  197. 	}
  198.   
  199.  
  200. 	//关闭所有套接字
  201. 	close(sfd);               
  202.  
  203. 	return 0;
  204. }

多进程

  1. #include<myhead.h>
  2.  
  3. #define PORT 8888              //端口号
  4. #define IP "192.168.114.74"       //IP地址
  5.  
  6. //定义函数处理客户端信息
  7. int deal_cli_msg(int newfd, struct sockaddr_in cin)
  8. {
  9.  
  10.     //收发数据使用newfd完成通信
  11.     char buf[128] = "";
  12.     while(1)
  13.     {
  14.         //清空字符串
  15.         bzero(buf, sizeof(buf));
  16.         //read(newfd, buf, sizeof(buf));        //从套接字中读取客户端发来的消息
  17.         int res = recv(newfd, buf, sizeof(buf), 0);        //从套接字中读取客户端发来的消息
  18.         //buf[strlen(buf)-1] = '\0';
  19.  
  20.         //判断收到的结果
  21.         if(res == 0)
  22.         {
  23.             printf("客户端已经下线\n");
  24.             break;
  25.         }else if(res < 0)
  26.         {
  27.             perror("recv error");
  28.             return -1;
  29.         }
  30.  
  31.         printf("[%s:%d]：%s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);
  32.  
  33.         //将读取的信息，加上一些字符发送回去
  34.         strcat(buf, "*_*");
  35.         //    write(newfd, buf, sizeof(buf));
  36.         send(newfd, buf, sizeof(buf), 0); 
  37.     }
  38.  
  39.     close(newfd);             //关闭通信的套接字
  40.  
  41.  
  42.  
  43.     return 0;
  44. }
  45.  
  46.  
  47.  
  48. //定义信号处理函数
  49. void handler(int signo)
  50. {
  51.     if(signo == SIGCHLD)
  52.     {
  53.         while(waitpid(-1, NULL, WNOHANG) > 0);       //非阻塞形式回收僵尸进程
  54.     }
  55. }
  56.  
  57.  
  58. int main(int argc, const char *argv[])
  59. {
  60.     //创建用于接受连接的套接字
  61.     int sfd = socket(AF_INET, SOCK_STREAM, 0);
  62.     if(sfd == -1)
  63.     {
  64.         perror("socket error");
  65.         return -1;
  66.     }
  67.  
  68.     printf("socket success\n");    
  69.  
  70.  
  71.     //设置端口号快速重用
  72.     int reuse = 1;
  73.     if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
  74.     {
  75.         perror("setsockopt error");
  76.         return -1;
  77.     }
  78.     printf("设置端口快速重用成功\n");
  79.  
  80.     //绑定IP地址和端口号
  81.     //填充要绑定的地址信息结构体
  82.     struct sockaddr_in sin;
  83.     sin.sin_family     = AF_INET;         //表明是ipv4
  84.     sin.sin_port     = htons(PORT);        //端口号
  85.     sin.sin_addr.s_addr = inet_addr(IP);     //IP地址
  86.  
  87.     //绑定
  88.     if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))==-1)
  89.     {
  90.         perror("bind error");
  91.         return -1;
  92.     }
  93.     printf("bind success\n");
  94.  
  95.     //将套接字设置成被动监听状态
  96.     if(listen(sfd, 128) == -1)
  97.     {
  98.         perror("listen error");
  99.         return -1;
  100.     }
  101.     printf("listen success\n");
  102.  
  103.     
  104.     //定义客户端地址信息结构体
  105.     struct sockaddr_in cin;             //客户端地址信息结构体
  106.     cin.sin_family     = AF_INET;
  107.     socklen_t socklen = sizeof(cin);          //客户端地址信息的大小
  108.  
  109.     //定义子进程变量
  110.     pid_t pid;
  111.  
  112.     //将SIGCHLD信号绑定到自定义信号处理函数中
  113.     if(signal(SIGCHLD, handler) == SIG_ERR)
  114.     {
  115.         perror("signal error");
  116.         return -1;
  117.     }
  118.  
  119.     while(1)
  120.     {    
  121.         //阻塞接收客户端的链接请求，并且获取客户端的地址信息
  122.         int newfd = accept(sfd, (struct sockaddr*)&cin, &socklen);
  123.         if(newfd == -1)
  124.         {
  125.             perror("accept error");
  126.             return -1;
  127.         }
  128.         printf("accept success\n");
  129.  
  130.         //创建子进程,让子进程完成通信
  131.         pid = fork();
  132.         if(pid > 0)
  133.         {
  134.             //关闭newfd
  135.             close(newfd);
  136.  
  137.             //回收僵尸进程
  138.             //wait(NULL);        
  139.  
  140.             
  141.         }else if(pid == 0)
  142.         {       
  143.             close(sfd);
  144.             //调用处理客户端函数
  145.             deal_cli_msg(newfd, cin);
  146.  
  147.             //退出子进程
  148.             exit(EXIT_SUCCESS);
  149.             
  150.         }else
  151.         {
  152.             perror("fork error");
  153.             return -1;
  154.         }
  155.     }
  156.  
  157.     
  158.     //关闭所有套接字
  159.     close(sfd);              
  160.  
  161.     return 0;
  162. }

多线程

  1. #include<myhead.h>
  2.  
  3. #define PORT 8888              //端口号
  4. #define IP "192.168.114.74"       //IP地址
  5.  
  6. //定义用于向线程体传参的结构体类型
  7. struct msg_info
  8. {
  9.     int newfd;
  10.     struct sockaddr_in cin;
  11. };
  12.  
  13.  
  14. //定义线程体函数
  15. void *deal_cli_msg(void *arg)
  16. {
  17.     //获取主线程传递的信息
  18.     int newfd = ((struct msg_info*)arg) -> newfd;
  19.     struct sockaddr_in cin = ((struct msg_info*)arg) -> cin;
  20.  
  21.     //收发数据使用newfd完成通信
  22.     char buf[128] = "";
  23.     while(1)
  24.     {
  25.         //清空字符串
  26.         bzero(buf, sizeof(buf));
  27.         //read(newfd, buf, sizeof(buf));        //从套接字中读取客户端发来的消息
  28.         int res = recv(newfd, buf, sizeof(buf), 0);        //从套接字中读取客户端发来的消息
  29.         //buf[strlen(buf)-1] = '\0';
  30.  
  31.         //判断收到的结果
  32.         if(res == 0)
  33.         {
  34.             printf("客户端已经下线\n");
  35.             break;
  36.         }else if(res < 0)
  37.         {
  38.             perror("recv error");
  39.             return NULL;
  40.         }
  41.  
  42.         printf("[%s:%d]：%s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);
  43.  
  44.         //将读取的信息，加上一些字符发送回去
  45.         strcat(buf, "*_*");
  46.         //    write(newfd, buf, sizeof(buf));
  47.         send(newfd, buf, sizeof(buf), 0); 
  48.     }
  49.  
  50.     close(newfd);             //关闭通信的套接字
  51.     ptread_exit(NULL);               //退出线程
  52.  
  53. }
  54.  
  55.  
  56.  
  57. int main(int argc, const char *argv[])
  58. {
  59.     //创建用于接受连接的套接字
  60.     int sfd = socket(AF_INET, SOCK_STREAM, 0);
  61.     if(sfd == -1)
  62.     {
  63.         perror("socket error");
  64.         return -1;
  65.     }
  66.  
  67.     printf("socket success sfd = %d\n", sfd);    //4
  68.  
  69.  
  70.     //设置端口号快速重用
  71.     int reuse = 1;
  72.     if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
  73.     {
  74.         perror("setsockopt error");
  75.         return -1;
  76.     }
  77.     printf("设置端口快速重用成功\n");
  78.  
  79.  
  80.     //绑定IP地址和端口号
  81.     //填充要绑定的地址信息结构体
  82.     struct sockaddr_in sin;
  83.     sin.sin_family     = AF_INET;         //表明是ipv4
  84.     sin.sin_port     = htons(PORT);        //端口号
  85.     sin.sin_addr.s_addr = inet_addr(IP);     //IP地址
  86.  
  87.     //绑定
  88.     if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))==-1)
  89.     {
  90.         perror("bind error");
  91.         return -1;
  92.     }
  93.     printf("bind success\n");
  94.  
  95.     //将套接字设置成被动监听状态
  96.     if(listen(sfd, 128) == -1)
  97.     {
  98.         perror("listen error");
  99.         return -1;
  100.     }
  101.  
  102.     printf("listen success\n");
  103.  
  104.     //阻塞等待客户端连接请求，如果有新的客户端连接，则创建一个新的用于通信的套接字
  105.     //客户端地址信息结构体
  106.     struct sockaddr_in cin;             //客户端地址信息结构体
  107.     cin.sin_family     = AF_INET;
  108.     socklen_t socklen = sizeof(cin);          //客户端地址信息的大小
  109.  
  110.     while(1)
  111.     {
  112.         //阻塞接收客户端的链接请求，并且获取客户端的地址信息
  113.         int newfd = accept(sfd, (struct sockaddr*)&cin, &socklen);
  114.         if(newfd == -1)
  115.         {
  116.             perror("accept error");
  117.             return -1;
  118.         }
  119.         printf("accept success\n");
  120.  
  121.         //定义用于向线程体传参的结构体变量
  122.         struct msg_info info = {newfd, cin};
  123.  
  124.         //创建分支线程用于通信
  125.         pthread_t tid;
  126.         if(pthread_create(&tid, NULL, deal_cli_msg, &info) != 0)
  127.         {
  128.             printf("分支线程创建失败\n");
  129.             return -1;
  130.         }
  131.  
  132.         //将该线程分离
  133.         if(pthread_detach(tid) != 0)
  134.         {
  135.             printf("分离失败\n");
  136.             return -1;
  137.         }
  138.  
  139.     }
  140.   
  141.  
  142.     //关闭所有套接字
  143.     close(sfd);               
  144.     return 0;
  145. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/77268
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号