循环服务器，并发服务器模型以及I/O多路转接模型

https://blog.csdn.net/xinianbuxiu/article/details/53455784

一、基于TCP/IP协议的基本循环服务器

tcp_server.c

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4.  

5. #include <sys/types.h>

6. #include <sys/socket.h>

7. #include <sys/stat.h>

8. #include <netdb.h>

9.  

10. #define PORT 3333

11. #define MAX_SIZE 1024

12.  

13. int main()

14. {

15. int sockfd;

16. int new_fd;

17.  

18. struct sockaddr_in server_addr;

19. struct sockaddr_in client_addr;

20.  

21. int n_read;

22. int ser_size;

23. int opt = 1;

24.  

25. char buffer[MAX_SIZE];

26.  

27. if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)

28. {

29. perror("socket error!\n");

30. exit(1);

31. }

32.  

33. printf("socket success.............!\n");

34.  

35. if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)) < 0)

36. {

37. perror("set socket option error!\n");

38. exit(1);

39. }

40.  

41. bzero(&server_addr,0);

42. server_addr.sin_family = AF_INET;

43. server_addr.sin_port = htons(PORT);

44. server_addr.sin_addr.s_addr = inet_addr("192.168.1.10");

45.  

46. if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)

47. {

48. perror("bind error!\n");

49. exit(1);

50. }

51.  

52. printf("bind success.............!\n");

53. listen(sockfd,5);

54.  

55. printf("listen success.............!\n");

56.  

57. printf("accepting..................!\n");

58.  

59. while(1)

60. {

61. ser_size = sizeof client_addr;

62.  

63. if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,&ser_size)) < 0)

64. {

65. perror("accept error!\n");

66. exit(1);

67. }

68.  

69. printf("accept success.................!\n");

70.  

71. //read\recv

72.  

73. printf("reading............!\n");

74. n_read = read(new_fd,buffer,sizeof(buffer));

75.  

76. if(n_read < 0)

77. {

78. perror("read client msg error!\n");

79. exit(1);

80. }

81.  

82. buffer[n_read] = '\0';

83.  

84. printf("recv msg = %s\n",buffer);

85. }

86.  

87. return 0;

88. }

tcp_client.c

1. #include <stdio.h>

2. #include <string.h>

3. #include <stdlib.h>

4.  

5. #include <sys/types.h>

6. #include <sys/socket.h>

7. #include <netdb.h>

8.  

9. #define PORT 3333

10. #define MAX_SIZE 1024

11.  

12. int main(int argc, char *argv[])

13. {

14. if(argc != 2)

15. {

16. printf("Please input server ip!\n");

17. exit(1);

18. }

19.  

20. int sockfd;

21. int n_write;

22.  

23. struct sockaddr_in server_addr;

24.  

25. char buffer[MAX_SIZE];

26.  

27. if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)

28. {

29. perror("client socket error!\n");

30. exit(1);

31. }

32.  

33. bzero(&server_addr,0);

34.  

35. server_addr.sin_family = AF_INET;

36. server_addr.sin_port = htons(PORT);

37. server_addr.sin_addr.s_addr = inet_addr(argv[1]);

38.  

39. if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)

40. {

41. perror("connect server error!\n");

42. exit(1);

43. }

44.  

45. while(1)

46. {

47. memset(buffer,0,sizeof(buffer));

48. printf("Please input send msg:\n");

49. gets(buffer);

50.  

51. n_write = write(sockfd,buffer,strlen(buffer));

52.  

53. if(n_write == -1)

54. {

55. perror("send to server msg error!\n");

56. exit(1);

57. }

58. }

59.  

60. return 0;

61. }

循环服务器能不断地接收客户端发送过来的信息，但是在面对多个客户端时，服务器必须等待第一个客户端发送信息才能接受其他客户端发来的信息。

由此，我们使用并发服务器，通过创建子进程，使得多个客户端能随时发信息给服务器

并发服务器：

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4.  

5. #include <sys/types.h>

6. #include <sys/socket.h>

7. #include <sys/stat.h>

8. #include <netdb.h>

9.  

10. #define PORT 3333

11. #define MAX_SIZE 1024

12.  

13. void * read_msg(void *arg)

14. {

15. int n_read;

16.  

17. int new_fd = *((int *)arg);

18.  

19. char buffer[MAX_SIZE];

20.  

21. printf("new_fd = %d\n",new_fd);

22.  

23. while(1)

24. {

25. memset(buffer,0,sizeof(buffer));

26.  

27. n_read = read(new_fd,buffer,sizeof(buffer));

28.  

29. if(n_read < 0)

30. {

31. perror("recv client msg error!\n");

32. exit(1);

33. }

34.  

35. if(n_read == 0)

36. {

37. printf("client is close!!\n");

38. close(new_fd);

39. pthread_exit(NULL);

40. }

41.  

42. buffer[n_read] = '\0';

43.  

44. printf("recv msg:%s\n",buffer);

45. }

46. }

47.  

48. int main()

49. {

50. int sockfd;

51. int new_fd;

52.  

53. struct sockaddr_in server_addr;

54. struct sockaddr_in client_addr;

55.  

56. int n_read;

57. int ser_size;

58. int opt = 1;

59.  

60. char buffer[MAX_SIZE];

61.  

62. pthread_t id;

63.  

64. if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)

65. {

66. perror("socket error!\n");

67. exit(1);

68. }

69.  

70. printf("socket success.............!\n");

71.  

72. if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)) < 0)

73. {

74. perror("set socket option error!\n");

75. exit(1);

76. }

77.  

78. bzero(&server_addr,0);

79. server_addr.sin_family = AF_INET;

80. server_addr.sin_port = htons(PORT);

81. server_addr.sin_addr.s_addr = inet_addr("192.168.1.10");

82.  

83. if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)

84. {

85. perror("bind error!\n");

86. exit(1);

87. }

88.  

89. printf("bind success.............!\n");

90. listen(sockfd,5);

91.  

92. printf("listen success.............!\n");

93.  

94. printf("accepting..................!\n");

95.  

96. while(1)

97. {

98. ser_size = sizeof client_addr;

99.  

100. if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,&ser_size)) < 0)

101. {

102. perror("accept error!\n");

103. exit(1);

104. }

105.  

106. printf("accept success.................!\n");

107.  

108. pthread_create(&id,NULL,read_msg,&new_fd);

109. }

110.  

111. return 0;

112. }

并发客户端：

1. #include <stdio.h>

2. #include <string.h>

3. #include <stdlib.h>

4.  

5. #include <sys/types.h>

6. #include <sys/socket.h>

7. #include <netdb.h>

8.  

9. #define PORT 3333

10. #define MAX_SIZE 1024

11.  

12. int main(int argc, char *argv[])

13. {

14. if(argc != 2)

15. {

16. printf("Please input server ip!\n");

17. exit(1);

18. }

19.  

20. int sockfd;

21. int n_write;

22.  

23. struct sockaddr_in server_addr;

24.  

25. char buffer[MAX_SIZE];

26.  

27. if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)

28. {

29. perror("client socket error!\n");

30. exit(1);

31. }

32.  

33. bzero(&server_addr,0);

34.  

35. server_addr.sin_family = AF_INET;

36. server_addr.sin_port = htons(PORT);

37. server_addr.sin_addr.s_addr = inet_addr(argv[1]);

38.  

39. if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)

40. {

41. perror("connect server error!\n");

42. exit(1);

43. }

44.  

45. while(1)

46. {

47. memset(buffer,0,sizeof(buffer));

48. printf("Please input send msg:\n");

49. gets(buffer);

50.  

51. n_write = write(sockfd,buffer,strlen(buffer));

52.  

53. if(n_write == -1)

54. {

55. perror("send to server msg error!\n");

56. exit(1);

57. }

58. }

59.  

60. return 0;

61. }

并发服务器模型的缺点是：客户端不再和服务器交互时，其多线程仍在工作，比较耗费CPU 的资源。

I/O多路转接模型：

利用一个“监听者”，当有客户端发出连接请求及客户端发送信息时，才会和服务器连接。

服务器代码：

1. #include <stdlib.h>

2. #include <stdio.h>

3. #include <errno.h>

4. #include <string.h>

5. #include <netdb.h>

6. #include <sys/types.h>

7. #include <netinet/in.h>

8. #include <sys/socket.h>

9. #include<unistd.h>

10. #include<arpa/inet.h>

11. #include<ctype.h>

12.  
13.  

14. #define portnumber 8000

15.  

16. #define MAX_LINE 80

17.  
18.  
19.  

20. int main(void)

21. {

22. int lfd;

23. int cfd;

24. int sfd;

25. int rdy;

26.  

27. struct sockaddr_in sin;

28. struct sockaddr_in cin;

29.  

30. int client[FD_SETSIZE];

31.  

32. int maxi;

33. int maxfd;

34.  

35. fd_set rset;

36. fd_set allset;

37.  

38. socklen_t addr_len;

39.  

40. char buffer[MAX_LINE];

41.  

42. int i;

43. int n;

44. int len;

45. int opt = 1;

46.  

47. char addr_p[20];

48.  
49.  

50. bzero(&sin,sizeof(struct sockaddr_in));

51. sin.sin_family=AF_INET;

52. sin.sin_addr.s_addr=htonl(INADDR_ANY);

53. sin.sin_port=htons(portnumber);

54.  
55.  

56. if((lfd=socket(AF_INET,SOCK_STREAM,0))==-1)

57. {

58. fprintf(stderr,"Socket error:%s\n\a",strerror(errno));

59. exit(1);

60. }

61. printf("socket!\n");

1.  

2. setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

3.  
4.  

5. if(bind(lfd,(struct sockaddr *)(&sin),sizeof(struct sockaddr))==-1)

6. {

7. fprintf(stderr,"Bind error:%s\n\a",strerror(errno));

8. exit(1);

9. }

10. printf("bind!\n");

11.  
12.  

13. if(listen(lfd,20)==-1)

14. {

15. fprintf(stderr,"Listen error:%s\n\a",strerror(errno));

16. exit(1);

17. }

18. printf("listen!\n");

19. printf("Accepting connections .......\n");

20.  

21. maxfd = lfd;

22. maxi = -1;

23.  
24.  

25. for(i = 0;i < FD_SETSIZE;i++)

26. {

27. client[i] = -1;

28. }

29. FD_ZERO(&allset);

30. FD_SET(lfd,&allset);

31.  
32.  
33.  

34. while(1)

35. {

36. rset = allset;

37. printf("selecting!\n");

38.  

39. rdy = select(maxfd + 1, &rset, NULL, NULL, NULL);

40.  

41. printf("selected!\n");

42. if(FD_ISSET(lfd, &rset))

43. {

44.  

45. addr_len = sizeof(sin);

46. printf("accepting!\n");

47.  

48. if((cfd=accept(lfd,(struct sockaddr *)(&cin),&addr_len))==-1)

49. {

50. fprintf(stderr,"Accept error:%s\n\a",strerror(errno));

51. exit(1);

52. }

53. printf("accepted!\n");

54.  
55.  
56.  

57. for(i = 0; i<FD_SETSIZE; i++)

58. { //printf("%d\t",client[i]);

59. if(client[i] <= 0)

60. {

61. client[i] = cfd;

62. break;

63. }

64. }

65.  
66.  

67. if(i == FD_SETSIZE)

68. {

69. printf("too many clients");

70. exit(1);

71. }

72.  

73. FD_SET(cfd, &allset);

74.  

75. if(cfd > maxfd)

76. {

77. maxfd = cfd;

78. }

79.  

80. if(i > maxi)

81. {

82. maxi = i;

83. }

84.  

85. if(--rdy <= 0)

86. {

87. continue;

88. }

89.  

90. }

91.  

92. for(i = 0;i< FD_SETSIZE;i++)

93. {

94. if((sfd = client[i]) < 0)

95. {

96. continue;

97. }

98.  

99. if(FD_ISSET(sfd, &rset))

100. {

101. printf("reading!\n");

102. n = read(sfd,buffer,MAX_LINE);

103. printf("%s\n",buffer);

104. printf("read!\n");

105. if(n == 0)

106. {

107. printf("the other side has been closed. \n");

108. fflush(stdout);

109. close(sfd);

110.  

111. FD_CLR(sfd, &allset);

112. client[i] = -1;

113. }

114.  

115. else

116. {

117.  

118. inet_ntop(AF_INET, &cin.sin_addr, addr_p, sizeof(addr_p));

119. addr_p[strlen(addr_p)] = '\0';

120.  
121.  

122. printf("Client Ip is %s, port is %d\n",addr_p,ntohs(cin.sin_port));

123.  
124.  
125.  

126. if(n == 1)

127. {

128. exit(1);

129. }

130. }

131.  
132.  

133. if(--rdy <= 0)

134. {

135. break;

136.  
137.  

138. }

139. }

140.  

141. }

142.  

143. close(lfd);

144. return 0;

145. }

多路转接客户端：

1. #include <stdlib.h>

2. #include <stdio.h>

3. #include <errno.h>

4. #include <string.h>

5. #include <netdb.h>

6. #include <sys/types.h>

7. #include <netinet/in.h>

8. #include <sys/socket.h>

9.  

10. #define portnumber 8000

11.  

12. int main(int argc, char *argv[])

13. {

14. int nbytes;

15. int sockfd;

16. char buffer[80];

17. char buffer_2[80];

18. struct sockaddr_in server_addr;

19. struct hostent *host;

20.  

21. if(argc!=2)

22. {

23. fprintf(stderr,"Usage:%s hostname \a\n",argv[0]);

24. exit(1);

25. }

26.  

27. if((host=gethostbyname(argv[1]))==NULL)

28. {

29. fprintf(stderr,"Gethostname error\n");

30. exit(1);

31. }

32.  
33.  

34. if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) // AF_INET:Internet;SOCK_STREAM:TCP

35. {

36. fprintf(stderr,"Socket Error:%s\a\n",strerror(errno));

37. exit(1);

38. }

39.  
40.  

41. bzero(&server_addr,sizeof(server_addr)); //

42. server_addr.sin_family=AF_INET;

43. server_addr.sin_port=htons(portnumber);

44. server_addr.sin_addr = *((struct in_addr *)host->h_addr);//址

45.  
46.  

47. if(connect(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)

48. {

49. fprintf(stderr,"Connect Error:%s\a\n",strerror(errno));

50. exit(1);

51. }

52.  

53. while(1){

54.  

55. printf("Please input char:\n");

56.  
57.  

58. fgets(buffer,1024,stdin);

59. write(sockfd,buffer,strlen(buffer));

60. #if 0

61. if((nbytes=read(sockfd,buffer_2,81))==-1)

62. {

63. fprintf(stderr,"Read Error:%s\n",strerror(errno));

64. exit(1);

65. }

66.  

67. buffer_2[nbytes]='\0';

68. printf("Client received from Server %s\n",buffer_2);

69. #endif

70.  
71.  

72. }

73. close(sockfd);

74. exit(0);

75. }