• Linux网络编程3——多进/线程并发服务器

    视频链接

    黑马程序员-Linux网络编程_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1iJ411S7UA?p=37

    目录

    一、高并发服务器

    1.1 图示

    1.2 分类

    二、多进程并发服务器

    2.1 回顾前面的内容

    2.2 步骤

    2.3 多进程并发服务器实现

    三、多线程并发服务器

    3.1 步骤

    3.2 多线程并发服务器实现

    一、高并发服务器

    1.1 图示

    1.2 分类

    多进程并发服务器

    多线程并发服务器

    二、多进程并发服务器

    2.1 回顾前面的内容

    服务端创建一个套接字 lfd，用来建立连接。客户端有连接请求的时候，借助 lfd 创建一个 cfd 套接字，客户端跟客户端 cfd 建立连接。再来一个客户端是和新创建的 cfd2 建立连接，所以 lfd 就一直处于空闲状态，等待其他客户端过来建立连接

    多进程中 cfd 就是子进程的角色，lfd 就是父进程的角色

    2.2 步骤

    第1步：创建监听套接字 lfd，使用函数 Socket();

    第2步：绑定地址结构 Struct scokaddr_in addr;，使用函数 Bind();

    第3步：让套接字进入监听状态并响应客户端请求，使用函数 Listen();

    第4步：

    while(1) {
            cfd = Accpet();  // 接受客户端连接请求
            pid = fork();      // 创建子进程
            if(pid == 0) {     // 子进程执行的操作
                    close(lfd); // 关闭用于建立连接的套接字 lfd（这是父进程的任务）
                    read();      // 从套接字中读取客户端发来的消息
                    小写字母转换成大写字母();
                    write();      // 写入用于通信的套接字中
            } else if (pid > 0) {  // 父进程
                    close(cfd);  // 关闭用于客户端通信的套接字
                    while(1) {  //等待子进程
                            waitpid(0, NULL, 0);  // 在这里循环调用不阻塞回收子进程会存在问题，所以后面写在回调函数中了
                    }
                    contiue;
            }
    }

    2.3 多进程并发服务器实现

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include
    12. #include
    13.  
    14. #include"wrap.h"
    15.  
    16. #define SRV_PORT 9999
    17.  
    18. void perr_exit(const char *s)
    19. {
    20. 	perror(s);
    21. 	exit(1);
    22. }
    23.  
    24. int main(int argc, char *argv[])
    25. {
    26. 	int lfd, cfd;
    27. 	pid_t pid;
    28. 	struct sockaddr_in srv_addr, clt_addr;
    29. 	socklen_t clt_addr_len;
    30. 	char buf[BUFSIZ];
    31. 	int ret, i;
    32. 	// 将地址结构清零	
    33. 	// 第一种方法: 
    34. 	// memset(&srv_addr, 0, sizeof(srv_addr));
    35. 	// 第二种方法:
    36. 	bzero(&srv_addr, sizeof(srv_addr));
    37.  
    38. 	srv_addr.sin_family = AF_INET;
    39. 	srv_addr.sin_port = htons(SRV_PORT);
    40. 	srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    41.  
    42. 	lfd = socket(AF_INET, SOCK_STREAM, 0);
    43.  
    44. 	bind(lfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr));
    45.  
    46. 	listen(lfd, 128);
    47. 	clt_addr_len = sizeof(clt_addr);
    48.  
    49. 	while (1) {
    50. 		cfd = accept(lfd, (struct sockaddr *)&clt_addr, &clt_addr_len);
    51. 		
    52. 		pid = fork();
    53. 		
    54. 		if (pid < 0) {
    55. 			perr_exit("fork error");
    56. 		} 
    57. 		else if (pid == 0) {
    58. 			close(lfd);
    59. 			break;
    60. 		}
    61. 		else {
    62. 			close(cfd);
    63. 			continue;
    64. 		}
    65. 	}
    66. 	
    67. 	// 子进程执行的操作
    68. 	if (pid == 0) {
    69. 		while(1) {
    70. 			ret = read(cfd, buf, sizeof(buf));
    71. 			if (ret == 0) {
    72. 				close(cfd);
    73. 				exit(1);
    74. 			}	
    75. 			for (i = 0; i < ret; i++) {
    76. 				buf[i] = toupper(buf[i]);
    77. 			}	
    78. 			write(cfd, buf, ret);
    79. 			write(STDOUT_FILENO, buf, ret);
    80. 		}
    81. 	}
    82.  
    83. 	return 0;
    84. }

    因为没回收子进程，所以有很多僵尸进程

    增加信号触发用于回收的函数

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include
    12. #include
    13.  
    14. #include"wrap.h"
    15.  
    16. #define SRV_PORT 9999
    17.  
    18. void perr_exit(const char *s)
    19. {
    20. 	perror(s);
    21. 	exit(1);
    22. }
    23.  
    24. void catch_child(int signum)
    25. {
    26. 	while (waitpid(0, NULL, WNOHANG) > 0);
    27. 	return ;
    28. }
    29.  
    30. int main(int argc, char *argv[])
    31. {
    32. 	int lfd, cfd;
    33. 	pid_t pid;
    34. 	struct sockaddr_in srv_addr, clt_addr;
    35. 	socklen_t clt_addr_len;
    36. 	char buf[BUFSIZ];
    37. 	int ret, i;
    38. 	// 将地址结构清零	
    39. 	// 第一种方法: 
    40. 	// memset(&srv_addr, 0, sizeof(srv_addr));
    41. 	// 第二种方法:
    42. 	bzero(&srv_addr, sizeof(srv_addr));
    43.  
    44. 	srv_addr.sin_family = AF_INET;
    45. 	srv_addr.sin_port = htons(SRV_PORT);
    46. 	srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    47.  
    48. 	lfd = socket(AF_INET, SOCK_STREAM, 0);
    49.  
    50. 	bind(lfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr));
    51.  
    52. 	listen(lfd, 128);
    53. 	clt_addr_len = sizeof(clt_addr);
    54.  
    55. 	while (1) {
    56. 		cfd = accept(lfd, (struct sockaddr *)&clt_addr, &clt_addr_len);
    57. 		
    58. 		pid = fork();
    59. 		
    60. 		if (pid < 0) {
    61. 			perr_exit("fork error");
    62. 		} 
    63. 		else if (pid == 0) {
    64. 			struct sigaction act;
    65. 			act.sa_handler = catch_child;
    66. 			sigemptyset(&act.sa_mask);
    67. 			act.sa_flags = 0;
    68.  
    69. 			ret = sigaction(SIGCHLD, &act, NULL);
    70. 			if (ret != 0) {
    71. 				perr_exit("sigaction error");
    72. 			}
    73. 			close(lfd);
    74. 			break;
    75. 		}
    76. 		else {
    77. 			close(cfd);
    78. 			continue;
    79. 		}
    80. 	}
    81. 	
    82. 	// 子进程执行的操作
    83. 	if (pid == 0) {
    84. 		while(1) {
    85. 			ret = read(cfd, buf, sizeof(buf));
    86. 			if (ret == 0) {
    87. 				close(cfd);
    88. 				exit(1);
    89. 			}	
    90. 			for (i = 0; i < ret; i++) {
    91. 				buf[i] = toupper(buf[i]);
    92. 			}	
    93. 			write(cfd, buf, ret);
    94. 			write(STDOUT_FILENO, buf, ret);
    95. 		}
    96. 	}
    97.  
    98. 	return 0;
    99. }

    三、多线程并发服务器

    3.1 步骤

    第1步：创建监听套接字 lfd，使用函数 Socket();

    第2步：绑定地址结构 Struct scokaddr_in addr;，使用函数 Bind();

    第3步：让套接字进入监听状态并响应客户端请求，使用函数 Listen();

    第4步：

    while(1) {
            cfd = Accpet(lfd);       // 接受客户端连接请求
            pthread_create(&tid, NULL, tfn, NULL);  // 创建子线程
            pthread_detach(tid);  // 前面是线程分离的函数，如果想接受子线程的返回值，需要 pthread_join(tid, void **); 这个函数，但是这个函数是阻塞等待的。我们可以创建一个新的线程专门用于回收这个子线程
    }

    第5步：

    void *tfn(void *arg)
    {
            close(lfd);
            read(cfd);
            小 -> 大
            write(cfd);
            pthread_exit((void*)10);
    }

    3.2 多线程并发服务器实现

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #define MAXLINE 8192
    13. #define SERV_PORT 8000
    14.  
    15. struct s_info {  // 定义一个结构体, 将地址结构跟cfd捆绑  
    16. 	struct sockaddr_in cliaddr;
    17. 	int connfd;
    18. };
    19.  
    20. void *do_work(void *arg)
    21. {
    22. 	int n,i;
    23. 	struct s_info *ts = (struct s_info*)arg;
    24. 	char buf[MAXLINE];
    25. 	char str[INET_ADDRSTRLEN];	// #define INET_ADDRSTRLEN 16  可用"[+d"查看  
    26.  
    27. 	while (1) {
    28. 		n = read(ts->connfd, buf, MAXLINE);  // 读客户端  
    29. 		if (n == 0) {
    30. 			printf("the client %d closed...\n", ts->connfd);
    31. 			break;  // 跳出循环,关闭cfd  
    32. 		}
    33. 		printf("received from %s at PORT %d\n",
    34. 				inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),
    35. 				ntohs((*ts).cliaddr.sin_port));	 // 打印客户端信息(IP/PORT)  
    36. 		for (i = 0; i < n; i++)
    37. 			buf[i] = toupper(buf[i]);  // 小写-->大写  
    38. 		write(STDOUT_FILENO, buf, n);  // 写出至屏幕  
    39. 		write(ts->connfd, buf, n);     // 回写给客户端  
    40. 	}
    41. 	close(ts->connfd);
    42. 	
    43. 	return (void *)0;
    44. }
    45.  
    46. int main(void)
    47. {
    48. 	struct sockaddr_in servaddr, cliaddr;
    49. 	socklen_t cliaddr_len;
    50. 	int listenfd, connfd;
    51. 	pthread_t tid;
    52.  
    53. 	struct s_info ts[256];  // 创建结构体数组  
    54. 	int i = 0;
    55.  
    56. 	listenfd = socket(AF_INET, SOCK_STREAM, 0);  // 创建一个socket, 得到lfd  
    57.  
    58. 	bzero(&servaddr, sizeof(servaddr));  // 地址结构清零  
    59. 	servaddr.sin_family = AF_INET;
    60. 	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  // 指定本地任意IP  
    61. 	servaddr.sin_port = htons(SERV_PORT);  // 指定端口号   
    62.  
    63. 	bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));  // 绑定  
    64.  
    65. 	listen(listenfd, 128);  // 设置同一时刻链接服务器上限数  
    66.  
    67. 	printf("Accepting client connect ...\n");
    68.  
    69. 	while (1) {
    70. 		cliaddr_len = sizeof(cliaddr);
    71. 		connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);  // 阻塞监听客户端链接请求  
    72. 		ts[i].cliaddr = cliaddr;
    73. 		ts[i].connfd = connfd;
    74. 		
    75. 		pthread_create(&tid, NULL, do_work, (void*)&ts[i]);
    76. 		pthread_detach(tid);  // 子线程分离,防止僵线程产生.  
    77. 		i++;
    78. 	}
    79.  
    80. 	return 0;
    81. }

    编译和运行 

  • 相关阅读:
    常见程序首页添加备案编号链接工信部
    选择排序算法(思路分析) [数据结构][Java]
    如何在雷电模拟器上安装Magisk并加载movecert模块抓https包（一）
    iptables总结存档
    计算机毕业设计Java紫陶文化传播与学习交流网站(源码+系统+mysql数据库+lw文档）
    OpenJudge NOI 2.1 6188:比饭量
    前端开发：export 和 export default的区别
    第二部分：Module（也称为Package）
    React 第一个Demo
    【Lilishop商城】No2-5.确定软件架构搭建四（本篇包括消息中间件RocketMQ）
  • 原文地址：https://blog.csdn.net/HuanBianCheng27/article/details/124866223