• lv7 嵌入式开发-网络编程开发 08 TCP并发功能

    目录

    1 TCP 多进程并发

    1.1 现象：

    1.2 多进程并发

    2 僵尸进程处理

    3 TCP并发多线程

    4 练习

    1 TCP 多进程并发

    1.1 现象：

    之前的代码，先关服务端，再次打开会出现错误bind:Address already in use

    使用setsockopt 地址快速重用可解决（后续会讲套接字设置）

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define BACKLOG 5
    11. void ClinetHandle(int newfd);
    12. int main(int argc, char *argv[])
    13. {
    14. 	int fd, newfd;
    15. 	struct sockaddr_in addr, clint_addr;
    16. 	socklen_t addrlen = sizeof(clint_addr);
    17. 	
    18. 	pid_t pid;
    19. 	
    20. 	if(argc < 3){
    21. 		fprintf(stderr, "%s\n", argv[0]);
    22. 		exit(0);
    23. 	}
    24.  
    25. 	/*创建套接字*/
    26. 	fd = socket(AF_INET, SOCK_STREAM, 0);
    27. 	if(fd < 0){
    28. 		perror("socket");
    29. 		exit(0);
    30. 	}
    31. 	addr.sin_family = AF_INET;
    32. 	addr.sin_port = htons( atoi(argv[2]) );
    33. 	if ( inet_aton(argv[1], &addr.sin_addr) == 0) {
    34. 		fprintf(stderr, "Invalid address\n");
    35. 		exit(EXIT_FAILURE);
    36. 	}
    37.  
    38. 	/*地址快速重用*/
    39. 	int flag=1,len= sizeof (int); 
    40. 	if ( setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, len) == -1) { 
    41. 		      perror("setsockopt"); 
    42. 			        exit(1); 
    43. 	} 
    44. 	/*绑定通信结构体*/
    45. 	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1){
    46. 		perror("bind");
    47. 		exit(0);
    48. 	}
    49. 	/*设置套接字为监听模式*/
    50. 	if(listen(fd, BACKLOG) == -1){
    51. 		perror("listen");
    52. 		exit(0);
    53. 	}
    54. 	while(1){
    55. 		/*接受客户端的连接请求，生成新的用于和客户端通信的套接字*/
    56. 		newfd = accept(fd, (struct sockaddr *)&clint_addr, &addrlen);
    57. 		if(newfd < 0){
    58. 			perror("accept");
    59. 			exit(0);
    60. 		}
    61. 		printf("addr:%s port:%d\n", inet_ntoa(clint_addr.sin_addr), ntohs(clint_addr.sin_port) );
    62. 		if( (pid = fork() ) < 0){
    63. 			perror("fork");
    64. 			exit(0);
    65. 		}else if(pid == 0){
    66. 			close(fd);
    67. 			ClinetHandle(newfd);
    68. 			exit(0);
    69. 		}
    70. 		else
    71. 			close(newfd);
    72. 	}
    73. 	close(fd);
    74. 	return 0;
    75. }
    76. void ClinetHandle(int newfd){
    77. 	int ret;
    78. 	char buf[BUFSIZ] = {};
    79. 	while(1){
    80. 		//memset(buf, 0, BUFSIZ);
    81. 		bzero(buf, BUFSIZ);
    82. 		ret = read(newfd, buf, BUFSIZ);
    83. 		if(ret < 0)
    84. 		{
    85. 			perror("read");
    86. 			exit(0);
    87. 		}
    88. 		else if(ret == 0)
    89. 			break;
    90. 		else
    91. 			printf("buf = %s\n", buf);
    92. 	}
    93. 	close(newfd);
    94. }

     原因：

    虽然程序关闭，但是系统认为服务还在，所以会出现这种情况。

    1.2 多进程并发

    复习fork函数，wait阻塞，会使得子进程结束，父进程才结束，这样两个printf都会打印。

    重点要fork（）之后的代码，都会执行两遍，一遍是子进程，一遍是父进程。

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. int main(int argc, char *argv[])
    6. {
    7. 	pid_t pid = fork();
    8. 	if(pid < 0){
    9. 		perror("fork");
    10. 		exit(0);
    11. 	}else if(pid == 0){
    12. 		printf("This is child process.\n");
    13. 	}else{
    14. 		printf("This is father process.\n");
    15. 		wait(NULL);
    16. 	}
    17. 	return 0;
    18. }

    多进程并发服务端实现：

    注意子进程和父进程中的处理细节，防止子进程产生孙进程，防止父、子进程未关闭占用的资源。

    另外启用了accept中两个原来参数，使用函数进行转换

    char * inet_ntoa(struct in_addr in);
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define BACKLOG 5
    11. void ClinetHandle(int newfd);
    12. int main(int argc, char *argv[])
    13. {
    14. 	int fd, newfd;
    15. 	struct sockaddr_in addr, clint_addr;
    16. 	socklen_t addrlen = sizeof(clint_addr);
    17. 	
    18. 	pid_t pid;
    19. 	
    20. 	if(argc < 3){
    21. 		fprintf(stderr, "%s\n", argv[0]);
    22. 		exit(0);
    23. 	}
    24.  
    25. 	/*创建套接字*/
    26. 	fd = socket(AF_INET, SOCK_STREAM, 0);
    27. 	if(fd < 0){
    28. 		perror("socket");
    29. 		exit(0);
    30. 	}
    31. 	addr.sin_family = AF_INET;
    32. 	addr.sin_port = htons( atoi(argv[2]) );
    33. 	if ( inet_aton(argv[1], &addr.sin_addr) == 0) {
    34. 		fprintf(stderr, "Invalid address\n");
    35. 		exit(EXIT_FAILURE);
    36. 	}
    37.  
    38. 	/*地址快速重用*/
    39. 	int flag=1,len= sizeof (int); 
    40. 	if ( setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, len) == -1) { 
    41. 		      perror("setsockopt"); 
    42. 			        exit(1); 
    43. 	} 
    44. 	/*绑定通信结构体*/
    45. 	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1){
    46. 		perror("bind");
    47. 		exit(0);
    48. 	}
    49. 	/*设置套接字为监听模式*/
    50. 	if(listen(fd, BACKLOG) == -1){
    51. 		perror("listen");
    52. 		exit(0);
    53. 	}
    54. 	while(1){
    55. 		/*接受客户端的连接请求，生成新的用于和客户端通信的套接字*/
    56. 		newfd = accept(fd, (struct sockaddr *)&clint_addr, &addrlen);
    57. 		if(newfd < 0){
    58. 			perror("accept");
    59. 			exit(0);
    60. 		}
    61.  
    62.         //注意理解转换函数
    63. 		printf("addr:%s port:%d\n", inet_ntoa(clint_addr.sin_addr), ntohs(clint_addr.sin_port) );
    64. 		if( (pid = fork() ) < 0){
    65. 			perror("fork");
    66. 			exit(0);
    67. 		}else if(pid == 0){
    68. 			close(fd);     //子进程需要关闭fd，对子进程来讲已经不适用fd了，占用了资源
    69. 			ClinetHandle(newfd);
    70. 			exit(0);       //退出子进程，防止后面生成孙进程，也进入了accept等待
    71. 		}
    72. 		else
    73. 			close(newfd);   //父进程关闭newfd，因为newfd被子进程占用了
    74. 	}
    75. 	close(fd);
    76. 	return 0;
    77. }
    78.  
    79. void ClinetHandle(int newfd){
    80. 	int ret;
    81. 	char buf[BUFSIZ] = {};
    82. 	while(1){
    83. 		//memset(buf, 0, BUFSIZ);
    84. 		bzero(buf, BUFSIZ);
    85. 		ret = read(newfd, buf, BUFSIZ);
    86. 		if(ret < 0)
    87. 		{
    88. 			perror("read");
    89. 			exit(0);
    90. 		}
    91. 		else if(ret == 0)
    92. 			break;  
    93. 		else
    94. 			printf("buf = %s\n", buf);
    95. 	}
    96. 	close(newfd);
    97. }

    实验效果:

    2 僵尸进程处理

    现象：如果客户端退出，会产生僵尸进程

    解决方法：使用信号的方式解决僵尸进程，注意flags设置为SA_RESTART的意义

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #define BACKLOG 5
    13. void SigHandle(int sig){
    14. 	if(sig == SIGCHLD){
    15. 		printf("client exited\n");
    16. 		wait(NULL);
    17. 	}
    18. }
    19. void ClinetHandle(int newfd);
    20. int main(int argc, char *argv[])
    21. {
    22. 	int fd, newfd;
    23. 	struct sockaddr_in addr, clint_addr;
    24. 	socklen_t addrlen = sizeof(clint_addr);
    25.  
    26. #if 0
    27. 	struct sigaction act;
    28. 	act.sa_handler = SigHandle;
    29. 	act.sa_flags = SA_RESTART;  //如果flag = 0会退出，那么让被终止的进程继续运行。注意实验
    30. 	sigemptyset(&act.sa_mask);
    31. 	sigaction(SIGCHLD, &act, NULL);
    32. #else
    33. 	signal(SIGCHLD, SigHandle);
    34. #endif
    35.  
    36. 	pid_t pid;
    37. 	
    38. 	if(argc < 3){
    39. 		fprintf(stderr, "%s\n", argv[0]);
    40. 		exit(0);
    41. 	}
    42.  
    43. 	/*创建套接字*/
    44. 	fd = socket(AF_INET, SOCK_STREAM, 0);
    45. 	if(fd < 0){
    46. 		perror("socket");
    47. 		exit(0);
    48. 	}
    49. 	addr.sin_family = AF_INET;
    50. 	addr.sin_port = htons( atoi(argv[2]) );
    51. 	if ( inet_aton(argv[1], &addr.sin_addr) == 0) {
    52. 		fprintf(stderr, "Invalid address\n");
    53. 		exit(EXIT_FAILURE);
    54. 	}
    55.  
    56. 	/*地址快速重用*/
    57. 	int flag=1,len= sizeof (int); 
    58. 	if ( setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, len) == -1) { 
    59. 		      perror("setsockopt"); 
    60. 			        exit(1); 
    61. 	} 
    62. 	/*绑定通信结构体*/
    63. 	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1){
    64. 		perror("bind");
    65. 		exit(0);
    66. 	}
    67. 	/*设置套接字为监听模式*/
    68. 	if(listen(fd, BACKLOG) == -1){
    69. 		perror("listen");
    70. 		exit(0);
    71. 	}
    72. 	while(1){
    73. 		/*接受客户端的连接请求，生成新的用于和客户端通信的套接字*/
    74. 		newfd = accept(fd, (struct sockaddr *)&clint_addr, &addrlen);
    75. 		if(newfd < 0){
    76. 			perror("accept");
    77. 			exit(0);
    78. 		}
    79. 		printf("addr:%s port:%d\n", inet_ntoa(clint_addr.sin_addr), ntohs(clint_addr.sin_port) );
    80. 		if( (pid = fork() ) < 0){
    81. 			perror("fork");
    82. 			exit(0);
    83. 		}else if(pid == 0){
    84. 			close(fd);
    85. 			ClinetHandle(newfd);
    86. 			exit(0);
    87. 		}
    88. 		else
    89. 			close(newfd);
    90. 	}
    91. 	close(fd);
    92. 	return 0;
    93. }
    94. void ClinetHandle(int newfd){
    95. 	int ret;
    96. 	char buf[BUFSIZ] = {};
    97. 	while(1){
    98. 		//memset(buf, 0, BUFSIZ);
    99. 		bzero(buf, BUFSIZ);
    100. 		ret = read(newfd, buf, BUFSIZ);
    101. 		if(ret < 0)
    102. 		{
    103. 			perror("read");
    104. 			exit(0);
    105. 		}
    106. 		else if(ret == 0)
    107. 			break;
    108. 		else
    109. 			printf("buf = %s\n", buf);
    110. 	}
    111. 	close(newfd);
    112. }

    3 TCP并发多线程

    目的：多线程占用的资源会更少

    复习：

    pthread_detach() 函数用于将指定的线程设置为分离模式。分离模式的线程在退出时会自动释放资源，不需要通过 pthread_join() 来等待线程结束并获取返回值。

    函数原型为：

    int pthread_detach(pthread_t thread);

    参数 thread 是要设置为分离模式的线程标识符。

    返回值：

    • 成功时，返回 0。
    • 失败时，返回一个非零的错误码。

    注意事项：

    • 必须在线程执行之前或者在其它线程中调用 pthread_detach() 函数，否则行为未定义。
    • 一旦线程被设置为分离模式，就无法再使用 pthread_join() 来等待线程结束。
    • 分离模式的线程会在退出时自动释放其资源，但必须确保线程在退出前不会产生资源泄漏。
    • 默认情况下，线程是非分离模式，需要显式调用 pthread_detach() 或 pthread_attr_setdetachstate() 函数将其设置为分离模式。

    示例用法：

    1. #include 
    2.  
    3. void* thread_func(void* arg) {
    4.     // 线程执行的代码
    5.     return NULL;
    6. }
    7.  
    8. int main() {
    9.     pthread_t tid;
    10.     // 创建线程
    11.  
    12.     if (pthread_create(&tid, NULL, thread_func, NULL) != 0) {
    13.         // 处理创建线程失败的情况
    14.         return -1;
    15.     }
    16.  
    17.     // 设置线程为分离模式
    18.     if (pthread_detach(tid) != 0) {
    19.         // 处理设置线程分离模式失败的情况
    20.         return -1;
    21.     }
    22.  
    23.     // 继续执行其他操作
    24.     // ...
    25.  
    26.     return 0;
    27. }
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BACKLOG 5
    12.  
    13. void *ClinetHandle(void *arg);
    14. int main(int argc, char *argv[])
    15. {
    16. 	int fd, newfd;
    17. 	struct sockaddr_in addr, clint_addr;
    18. 	pthread_t tid;
    19. 	socklen_t addrlen = sizeof(clint_addr);
    20. 	
    21. 	if(argc < 3){
    22. 		fprintf(stderr, "%s\n", argv[0]);
    23. 		exit(0);
    24. 	}
    25.  
    26. 	/*创建套接字*/
    27. 	fd = socket(AF_INET, SOCK_STREAM, 0);
    28. 	if(fd < 0){
    29. 		perror("socket");
    30. 		exit(0);
    31. 	}
    32. 	addr.sin_family = AF_INET;
    33. 	addr.sin_port = htons( atoi(argv[2]) );
    34. 	if ( inet_aton(argv[1], &addr.sin_addr) == 0) {
    35. 		fprintf(stderr, "Invalid address\n");
    36. 		exit(EXIT_FAILURE);
    37. 	}
    38.  
    39. 	/*地址快速重用*/
    40. 	int flag=1,len= sizeof (int); 
    41. 	if ( setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, len) == -1) { 
    42. 		      perror("setsockopt"); 
    43. 			        exit(1); 
    44. 	} 
    45. 	/*绑定通信结构体*/
    46. 	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1){
    47. 		perror("bind");
    48. 		exit(0);
    49. 	}
    50. 	/*设置套接字为监听模式*/
    51. 	if(listen(fd, BACKLOG) == -1){
    52. 		perror("listen");
    53. 		exit(0);
    54. 	}
    55. 	while(1){
    56. 		/*接受客户端的连接请求，生成新的用于和客户端通信的套接字*/
    57. 		newfd = accept(fd, (struct sockaddr *)&clint_addr, &addrlen);
    58. 		if(newfd < 0){
    59. 			perror("accept");
    60. 			exit(0);
    61. 		}
    62. 		printf("addr:%s port:%d\n", inet_ntoa(clint_addr.sin_addr), ntohs(clint_addr.sin_port) );
    63. 		pthread_create(&tid, NULL, ClinetHandle, &newfd);
    64. 		pthread_detach(tid);  //把线程属性设置为分离模式
    65. 	}
    66. 	close(fd);
    67. 	return 0;
    68. }
    69. void *ClinetHandle(void *arg){
    70. 	int ret;
    71. 	char buf[BUFSIZ] = {};
    72. 	int newfd = *(int *)arg;
    73. 	while(1){
    74. 		//memset(buf, 0, BUFSIZ);
    75. 		bzero(buf, BUFSIZ);
    76. 		ret = read(newfd, buf, BUFSIZ);
    77. 		if(ret < 0)
    78. 		{
    79. 			perror("read");
    80. 			exit(0);
    81. 		}
    82. 		else if(ret == 0)
    83. 			break;
    84. 		else
    85. 			printf("buf = %s\n", buf);
    86. 	}
    87. 	printf("client exited\n");
    88. 	close(newfd);
    89. 	return NULL;
    90. }

    makefile也需要修改

    1.  
    2. CC=gcc
    3. CFLAGS=-Wall
    4. all:client server
    5.  
    6. server:server.c
    7. 	$(CC) $^ -Wall -o $@ -lpthread
    8.  
    9. clean:
    10. 	rm client server

    4 练习

    使用多线程实现TCP并发代码，并使用Makefile进行编译。提交代码和完成通信的截图

    tcp_server.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define CLIENT_MAX_NUM 5
    11.  
    12. void * ClientHandle(void *arg);
    13.  
    14. int main(int argc, char * argv[])
    15. {
    16. 	int sockfd, clientfd;
    17. 	struct sockaddr_in server_addr,client_addr;
    18. 	pthread_t tid;
    19. 	socklen_t addrlen = sizeof(client_addr);
    20.  
    21. 	if( argc < 3)
    22. 	{
    23. 		printf("%s  \n",argv[0]);
    24. 		return 0;
    25. 	}
    26.  
    27. 	//1 创建socket
    28. 	sockfd = socket(AF_INET, SOCK_STREAM,0);
    29. 	if(sockfd == -1)
    30. 	{
    31. 		perror("socket");
    32. 		return 0;
    33. 	}
    34.  
    35. 	server_addr.sin_family = AF_INET;
    36. 	server_addr.sin_port = htons( atoi(argv[2]) ) ;
    37. 	if( inet_aton(argv[1], &server_addr.sin_addr) == 0)
    38. 	{
    39. 		printf("Invalid address:%s\n",argv[1]);
    40. 		return 0;
    41. 	}
    42. 	
    43. 	/*地址快速重用*/
    44. 	int flag = 1, len = sizeof(int);
    45. 	if( setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag,len) == -1)
    46. 	{
    47. 		perror("setsockopt");
    48. 		return 0;
    49. 	}
    50. 	
    51. 	//2 绑定bind
    52. 	if(bind(sockfd, (struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)
    53. 	{
    54. 		perror("bind");
    55. 		return 0;
    56. 	}
    57.  
    58. 	//3 监听
    59. 	if(listen(sockfd, CLIENT_MAX_NUM) == -1)
    60. 	{
    61. 		perror("listen");
    62. 		return 0;
    63. 	}
    64.  
    65. 	while(1)
    66. 	{
    67. 		//4 等待连接
    68. 		clientfd = accept(sockfd, (struct sockaddr *)&client_addr, &addrlen); 
    69. 		
    70. 		if( clientfd == -1)
    71. 		{
    72. 			perror("accept");
    73. 			return 0;
    74. 		}
    75. 		printf("addr:%s port:%d\n",inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    76. 		pthread_create(&tid, NULL, ClientHandle, &clientfd);
    77. 		pthread_detach(tid);  //线程属性设置为分离模式
    78.  
    79. 	}
    80. 	close(sockfd);
    81. 	return 0;
    82. }
    83.  
    84.  
    85.  
    86. void * ClientHandle(void *arg)
    87. {
    88. 	int ret;
    89. 	char buf[BUFSIZ] = {};
    90. 	int clientfd = *(int *)arg;
    91.  
    92. 	while(1)
    93. 	{
    94. 		//bzero(buf, BUFSIZ);
    95. 		memset(buf, 0, BUFSIZ);
    96. 		ret = read(clientfd, buf, BUFSIZ);
    97. 		if(ret < 0)
    98. 		{
    99. 			perror("read");
    100. 			exit(0);
    101. 		}
    102. 		else if( ret == 0 )
    103. 		{
    104. 			break;
    105. 		}
    106. 		else
    107. 		{
    108. 			printf("buf = %s\n", buf);
    109. 		}	
    110. 	}
    111. 	printf("client exited\n");
    112. 	close(clientfd);
    113. 	return NULL;
    114.  
    115. }

    tcp_client.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #define CLIENT_MAX_NUM 5
    10.  
    11. int main(int argc, char * argv[])
    12. {
    13. 	int clientfd;
    14. 	struct sockaddr_in server_addr;
    15. 	char buf[BUFSIZ];
    16.  
    17. 	if( argc < 3)
    18. 	{
    19. 		printf("%s  \n",argv[0]);
    20. 		return 0;
    21. 	}
    22.  
    23. 	clientfd = socket(AF_INET, SOCK_STREAM,0);
    24. 	if(clientfd == -1)
    25. 	{
    26. 		perror("socket");
    27. 		return 0;
    28. 	}
    29.  
    30. 	server_addr.sin_family = AF_INET;
    31. 	server_addr.sin_port = htons( atoi(argv[2]) ) ;
    32. 	if( inet_aton(argv[1], &server_addr.sin_addr) == 0)
    33. 	{
    34. 		printf("Invalid address:%s\n",argv[1]);
    35. 		return 0;
    36. 	}
    37.  
    38. 	if(connect(clientfd, (struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)
    39. 	{
    40. 		perror("connect");
    41. 		return 0;
    42. 	}
    43.  
    44.  
    45. 	while(1)
    46. 	{
    47. 		printf(">");
    48. 		fgets(buf, BUFSIZ, stdin);
    49. 		write(clientfd, buf, strlen(buf));
    50. 	}
    51. 	close(clientfd);
    52. 	return 0;
    53. }

    makefile

    1. CC=gcc
    2. CFLAGS=-Wall
    3. all:tcp_client tcp_server
    4. tcp_server:tcp_server.c
    5. 	$(CC) tcp_server.c -Wall -o tcp_server -lpthread
    6.  
    7. clean:
    8. 	rm tcp_server tcp_client

  • 相关阅读:
    Redis 定长队列的探索和实践
    Java中的map集合顺序如何与添加顺序一样，LinkedHashMap，使用entrySet遍历
    最小生成树——Prim算法与Kruskal算法
    【DL with Pytorch】第 4 章 ： 卷积神经网络
    精心整理了超详细的Linux入门笔记，零基础也能看懂，一学就会
    【软件部署】Linux源码安装Jenkins
    【学习笔记】深度学习入门：基于Python的理论与实现-神经网络
    【一】曾经那些错误，你又踩坑了吗？
    金仓数据库KingbaseES安全指南--6.7. GSSAPI身份验证
    企业架构概述及业务架构详解
  • 原文地址：https://blog.csdn.net/m0_60718520/article/details/133563674