简约而不简单epoll之EPOLLOUT

随笔记录

select模型，poll模型，epoll模型对比

	select	poll	epoll
支持最大连接数	1024	无上限	无上限
IO效率	每次调用都要进行遍历，时间复杂度O(n)	每次调用都要进行遍历，时间复杂度O(n)	使用事件通知方式，每当fd就绪，系统注册的回调函数就会被调用，将就绪fd放到rdllist里面，这样epoll_wait返回的时候我们就拿到了就绪的fd,时间复杂度O(1)
fd拷贝	每次select都拷贝，fd数组	每次poll都拷贝fd数组	调用epoll_ctl时拷贝进内核并由内核保存，之后每次epoll_wait不拷贝

    本篇主要分析epoll边缘触发，通过模拟各种场景，来介绍EPOLLOUT，不涉及epoll底层源码实现。

一、序

epoll_wait返回的条件

1、等待时间到期

2、发生信号事件，例如ctrl+c

3、The associated file is available for read(2) operations，如果注册了EPOLLIN， socket接收缓冲区，有新的数据到来

4、The associated file is available for write(2) operations，如果注册了EPOLLOUT， socket发送缓冲区可写时

前三种场景比较容易理解，但是第4种场景却需要深入研究一下，通过man epoll_ctl手册，可以得到官方对于EPOLLOUT解释，就是上面英文，那么在写代码的时候我们应该如何考虑呢，EPOLLOUT呢？。

二、EPOLLIN|EPOLLOUT同时注册到epoll事件模型

结论1：将EPOLLET|EPOLLIN|EPOLLOUT 注册到epoll中， 然后调用epoll_wait会立刻返回，并且只有EPOLLOUT事件，这个属于第一次EPOLLOUT事件，原因是缓冲区可写。

模拟场景1： client 调用connect后，直接睡眠10s，不发送也不接受任何数据，10s后直接退出。观察server端会有EPOLLOUT打印

代码1：

服务端代码：

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <strings.h>

5. #include <unistd.h>

6. #include <fcntl.h>

7. #include <errno.h>

8. #include <netinet/in.h>

9. #include <arpa/inet.h>

10. #include <sys/socket.h>

11. #include <sys/epoll.h>

14. #define SERVPORT 9527

15. #define MAXBUF 8192

16. #define MAXFDS 5000

17. #define EVENTSIZE 100

19. char sndMsg[MAXBUF] = {0};

21. int setnonblocking(int fd)

22. {

23. int opts;

24. if( (opts = fcntl(fd, F_GETFL, 0)) == -1) {

25. perror("fcntl");

26. return -1;

27. }

29. opts = opts | O_NONBLOCK;

30. if( (opts = fcntl(fd, F_SETFL, opts)) == -1) {

31. perror("fcntl");

32. return -1;

33. }

35. return 0;

36. }

38. int main(void)

39. {

40. char buf[MAXBUF];

41. int len, n;

43. struct sockaddr_in servaddr;

44. int sockfd, listenfd, epollfd, nfds;

46. struct epoll_event ev;

47. struct epoll_event events[EVENTSIZE];

49. bzero(&servaddr, sizeof(servaddr));

50. servaddr.sin_family = AF_INET;

51. servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

52. servaddr.sin_port = htons(SERVPORT);

54. if( (epollfd = epoll_create(MAXFDS)) == -1) {

55. perror("epoll");

56. exit(1);

57. }

59. if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

60. perror("socket");

61. exit(1);

62. }

64. if(setnonblocking(listenfd) == -1){

65. perror("setnonblocking");

66. exit(1);

67. }

69. if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {

70. perror("bind");

71. exit(1);

72. }

74. if(listen(listenfd, 10) == -1) {

75. perror("listen");

76. exit(1);

77. }

79. // listen fd只注册EPOLLIN事件， EPOLLOUT不需要注册

80. ev.events = EPOLLIN | EPOLLET;

81. ev.data.fd = listenfd;

82. if(epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {

83. perror("epoll_ctl");

84. exit(1);

85. }

87. for( ; ; ) {

88. if( (nfds = epoll_wait(epollfd, events, EVENTSIZE, -1)) == -1) {

89. perror("epoll_wait");

90. exit(1);

91. }

93. for(n = 0; n < nfds; n++) {

94. if(events[n].data.fd == listenfd) {

95. while( (sockfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) > 0) {

96. if(setnonblocking(sockfd) == -1) {

97. perror("setnonblocking");

98. exit(1);

99. }

100. //新的fd： 采用边缘触发且注册IN、OUT事件

101. ev.events = EPOLLIN | EPOLLOUT | EPOLLET;

102. ev.data.fd = sockfd;

103. if(epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev) == -1) {

104. perror("epoll_ctl");

105. exit(1);

106. } else {

107. printf("new socketfd = %d register epoll success\n", sockfd);

108. }

109. }

110. continue;

111. }

112. printf("Events = 0x%x\n", events[n].events);

113. if (events[n].events & (EPOLLIN | EPOLLOUT) == (EPOLLIN | EPOLLOUT)) {

114. printf(">> EPOLLIN And EPOLLOUT event， socketfd = %d\n", events[n].data.fd);

115. }

116. else if (events[n].events & EPOLLIN) {

117. printf(">> Only EPOLLIN event， socketfd = %d\n", events[n].data.fd);

118. }

119. else if (events[n].events & EPOLLOUT) {

120. printf(">> Only EPOLLOUT， socketfd = %d\n", events[n].data.fd);

121. }

122. }

123. }

124. }

客户端代码：

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <unistd.h>

5. #include <strings.h>

6. #include <netinet/in.h>

7. #include <arpa/inet.h>

8. #include <sys/socket.h>

10. #define SERVPORT 9527

11. #define MAXBUF 1024

13. int main(void)

14. {

15. char buf[MAXBUF];

16. struct sockaddr_in servaddr;

17. int fd;

18. int n, len;

20. bzero(&servaddr, sizeof(servaddr));

21. servaddr.sin_family = AF_INET;

22. servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

23. servaddr.sin_port = htons(SERVPORT);

25. if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

26. perror("socket");

27. exit(1);

28. }

30. if (connect(fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {

31. perror("connect");

32. exit(1);

33. }

34. printf("Connection ok, Send data after sleep 10s.\n");

35. sleep(10);

36. printf(">> bye bye\n");

37. close(fd);// 会出发server端 EPOLLIN和EPOLLOUT

38. return 0;

39. }

输出结果：

结论2：在注册的时候，将EPOLLET|EPOLLIN|EPOLLOUT注册到epoll中，然后客户端client发送数据，server就会触发EPOLLIN|EPOLLOUT， 原因还是缓冲区是可以写的。

模拟场景2：建立连接后clien立即发送数据，每次间隔5秒，server端不调用recv函数也不调用send函数。

输出结果：执行了两次，两次基本相同，只不过是第二次多出现一个Only EPOLLOUT。

代码：

服务端-与结论1中代码相同，此处不在罗列

客户端：

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <unistd.h>

5. #include <strings.h>

6. #include <netinet/in.h>

7. #include <arpa/inet.h>

8. #include <sys/socket.h>

10. #define SERVPORT 9527

11. #define MAXBUF 1024

13. int main(void)

14. {

15. char buf[MAXBUF];

16. struct sockaddr_in servaddr;

17. int fd;

18. int n, len;

20. bzero(&servaddr, sizeof(servaddr));

21. servaddr.sin_family = AF_INET;

22. servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

23. servaddr.sin_port = htons(SERVPORT);

25. if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)

26. {

27. perror("socket");

28. exit(1);

29. }

31. if (connect(fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)

32. {

33. perror("connect");

34. exit(1);

35. }

36. printf(">> Send \"helloworld-1\"\n");

37. send(fd, "helloworld-1", sizeof("helloworld-1") - 1, 0);

38. sleep(5);

39. printf(">> Send \"helloworld-2\"\n");

40. send(fd, "helloworld-2", sizeof("helloworld-2") - 1, 0);

41. printf("Will colse after sleep 8s.\n");

42. sleep(8);

43. close(fd);

44. return 0;

45. }

结论3：在注册的时候，将EPOLLET|EPOLLIN|EPOLLOUT注册到epoll中， client不发送也不接收数据，sever一直
发送数据，直到将socket发送缓冲区打满， 此时client发送数据到server端， 这时server只会触发EPOLLIN事件
没有EPOLLOUT，原因是发送缓冲区是满的，不可写，所以不会触发EPOLLOUT。

模拟场景：设置server端socket 发送缓冲区是4096（4k）， 设置client端接收rcvbuf缓冲区3072（3k），客户端不接收数据即不调用recv函数，服务端一直发送数据，最终会把服务端发送缓冲区打满，我们这里改变缓冲区大小，只是为了更快打满缓冲区。

输出数据：

代码：

服务端代码：

2. #include <stdio.h>

3. #include <stdlib.h>

4. #include <string.h>

5. #include <strings.h>

6. #include <unistd.h>

7. #include <fcntl.h>

8. #include <errno.h>

9. #include <netinet/in.h>

10. #include <arpa/inet.h>

11. #include <sys/socket.h>

12. #include <sys/epoll.h>

15. #define SERVPORT 9527

16. #define MAXBUF 1024*1024 //1MB

17. #define MAXFDS 5000

18. #define EVENTSIZE 100

20. int setnonblocking(int fd)

21. {

22. int opts;

23. if( (opts = fcntl(fd, F_GETFL, 0)) == -1)

24. {

25. perror("fcntl");

26. return -1;

27. }

29. opts = opts | O_NONBLOCK;

30. if( (opts = fcntl(fd, F_SETFL, opts)) == -1)

31. {

32. perror("fcntl");

33. return -1;

34. }

36. return 0;

37. }

39. int main(void)

40. {

41. int len = 0, n = 0, once = 0;

42. int hasSend;

43. char buf[MAXBUF] = {0};

44. char sndMsg[MAXBUF] = {1};

46. struct sockaddr_in servaddr;

47. int sockfd, listenfd, epollfd, nfds;

49. struct epoll_event ev;

50. struct epoll_event events[EVENTSIZE];

52. bzero(&servaddr, sizeof(servaddr));

53. servaddr.sin_family = AF_INET;

54. servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

55. servaddr.sin_port = htons(SERVPORT);

57. if( (epollfd = epoll_create(MAXFDS)) == -1) {

58. perror("epoll");

59. exit(1);

60. }

62. if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

63. perror("socket");

64. exit(1);

65. }

67. if(setnonblocking(listenfd) == -1) {

68. perror("setnonblocking");

69. exit(1);

70. }

72. if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {

73. perror("bind");

74. exit(1);

75. }

77. if(listen(listenfd, 10) == -1) {

78. perror("listen");

79. exit(1);

80. }

83. ev.events = EPOLLIN | EPOLLET;

84. ev.data.fd = listenfd;

85. if(epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {

86. perror("epoll_ctl");

87. exit(1);

88. }

90. for( ; ; ) {

91. if( (nfds = epoll_wait(epollfd, events, EVENTSIZE, -1)) == -1) {

92. perror("epoll_wait");

93. exit(1);

94. }

96. for(n = 0; n < nfds; n++) {

97. if(events[n].data.fd == listenfd) {

98. while( (sockfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) > 0) {

99. if(setnonblocking(sockfd) == -1) {

100. perror("setnonblocking");

101. exit(1);

102. }

103. ev.events = EPOLLIN | EPOLLOUT | EPOLLET;

104. ev.data.fd = sockfd;

105. int nSendBuf = 4096; //上层应用设置成4096 但是底层内核实际是4096*2 = 8192

106. socklen_t opt_len = sizeof(int);

107. int ret = setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &nSendBuf, sizeof(int));

108. if (ret == -1) {

109. perror("setsockopt");

110. }

111. getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &nSendBuf, &opt_len);

112. printf("SndBuf-new = %d\n", nSendBuf);

113. if(epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev) == -1)

114. {

115. perror("epoll_ctl");

116. exit(1);

117. } else {

118. printf("new socketfd = %d register epoll success\n", sockfd);

119. }

120. }

121. continue;

122. }

124. printf("Events = 0x%x\n", events[n].events);

125. if (events[n].events & EPOLLIN && events[n].events & EPOLLOUT) {

126. printf(">> EPOLLIN And EPOLLOUT event， socketfd = %d\n", events[n].data.fd);

127. len = recv(events[n].data.fd, buf, MAXBUF, 0);

128. len = send(events[n].data.fd, sndMsg + hasSend, MAXBUF-hasSend, 0);

129. if (len > 0) {// 说明发送成功

130. hasSend += len;

131. once = 0;

132. printf("EPOLLIN | EPOLLOUT ==》 Send ok， length = %d.\n", len);

133. } else if (len == -1) {

134. if (errno == EAGAIN) {//说明发送缓冲区已经满

135. printf("EPOLLIN | EPOLLOUT ==》 Socket SndBuf is fulled. \n");

136. }

137. } else {//出现错误

138. perror("EPOLLIN | EPOLLOUT ==》 Send failed.\n");

139. exit(-1);

140. }

141. }

142. else if (events[n].events & EPOLLIN) {

143. printf(">> Only EPOLLIN event， socketfd = %d\n", events[n].data.fd);

144. }

145. else if (events[n].events & EPOLLOUT) {

146. printf(">> Only EPOLLOUT， socketfd = %d\n", events[n].data.fd);

148. while (1) {

149. len = send(events[n].data.fd, sndMsg + hasSend, MAXBUF-hasSend, 0);

150. if (len > 0) {// 说明发送成功

151. hasSend += len;

152. once = 0;

153. printf("Send ok， length = %d.\n", len);

154. } else if (len == -1) {

155. if (errno == EAGAIN) {//说明发送缓冲区已经满

156. printf(" EPOLLOUT ==》 Socket SndBuf is fulled. \n");

157. break;

158. }

159. } else {//出现错误

160. perror(" EPOLLOUT ==》 Send failed.\n");

161. exit(-1);

162. }

163. }

164. }

165. }

166. }

167. }

客户端代码：

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <unistd.h>

5. #include <strings.h>

6. #include <netinet/in.h>

7. #include <arpa/inet.h>

8. #include <sys/socket.h>

10. #define SERVPORT 9527

11. #define MAXBUF 1024

13. int main(void)

14. {

15. char buf[MAXBUF];

16. struct sockaddr_in servaddr;

17. int fd;

18. int n, len;

20. bzero(&servaddr, sizeof(servaddr));

21. servaddr.sin_family = AF_INET;

22. servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

23. servaddr.sin_port = htons(SERVPORT);

25. if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)

26. {

27. perror("socket");

28. exit(1);

29. }

31. int nSendBuf = 0;

32. socklen_t opt_len = sizeof(int);

33. nSendBuf = 3072;

34. int ret = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &nSendBuf, sizeof(int));

35. if (ret == -1) {

36. perror("setsockopt");

37. }

38. getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &nSendBuf, &opt_len);

39. printf("Client recvbuf len = %d\n", nSendBuf);

40. if (connect(fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)

41. {

42. perror("connect");

43. exit(1);

44. }

45. printf("Connection ok, sleep 30s\n");

46. sleep(30); //睡眠60秒保证 服务端缓冲区被打满

47. printf("Send msg==>""hello server!! do you sndbuf is fulled?\n");

48. send(fd, "hello server!! do you sndbuf is fulled?", strlen("hello server!! do you sndbuf is fulled?"), 0);

49. sleep(10);

50. send(fd, "hello server!! do you sndbuf is fulled?", strlen("hello server!! do you sndbuf is fulled?"), 0);

51. sleep(10);

52. close(fd);

54. return 0;

55. }

结论4：在注册的时候，将EPOLLET|EPOLLIN|EPOLLOUT注册到epoll中， client不发送也不接收数据，sever一直发送数据，直到将socket 发送缓冲区打满， 此时client 开始连续接收n次数据（不发送数据）， 此时server又会产生EPOLLOUT，因为发送缓冲区变成可写（由满->不满），由于服务端要发送1MB数据，客户端每次只读取256字节，所有服务端发送缓冲区状态变化是：满->不满->满（不可写->可写->不可写）。

输出数据：

代码：

服务端，与结论3中服务端代码一样

客户端代码：

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <strings.h>

5. #include <unistd.h>

6. #include <fcntl.h>

7. #include <errno.h>

8. #include <netinet/in.h>

9. #include <arpa/inet.h>

10. #include <sys/socket.h>

11. #include <sys/epoll.h>

13. #define SERVPORT 9527

14. #define MAXBUF 1024

16. int setnonblocking(int fd)

17. {

18. int opts;

19. if( (opts = fcntl(fd, F_GETFL, 0)) == -1)

20. {

21. perror("fcntl");

22. return -1;

23. }

25. opts = opts | O_NONBLOCK;

26. if( (opts = fcntl(fd, F_SETFL, opts)) == -1)

27. {

28. perror("fcntl");

29. return -1;

30. }

32. return 0;

33. }

35. int main(void)

36. {

37. char buf[MAXBUF];

38. struct sockaddr_in servaddr;

39. int fd;

40. int n, len;

42. bzero(&servaddr, sizeof(servaddr));

43. servaddr.sin_family = AF_INET;

44. servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

45. servaddr.sin_port = htons(SERVPORT);

47. if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)

48. {

49. perror("socket");

50. exit(1);

51. }

53. int nSendBuf = 0;

54. socklen_t opt_len = sizeof(int);

55. nSendBuf = 3072;

56. int ret = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &nSendBuf, sizeof(int));

57. if (ret == -1) {

58. perror("setsockopt");

59. }

61. getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &nSendBuf, &opt_len);

62. printf("Client recvbuf len = %d\n", nSendBuf);

64. if (connect(fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)

65. {

66. perror("connect");

67. exit(1);

68. }

69. setnonblocking(fd); //设置成非阻塞

70. printf("Connection ok, sleep 10s\n");

71. sleep(10); //睡眠10秒保证 服务端缓冲区被打满

73. while(1) {

74. len = recv(fd, buf, 256, 0);// 由于服务端发送的数据是1MB所以需要多次调用

75. if (len > 0) {

76. n += len;

77. } else if (len == -1 && errno == EAGAIN) {

78. printf("EAGAIN, Has recv n = %d\n", n);

79. sleep(3);

80. } else {

81. printf("Recv failed.\n");

82. exit(-1);

83. }

84. }

85. close(fd);

86. return 0;

87. }

结论5：在注册的时候，将EPOLLET|EPOLLIN|EPOLLOUT注册到epoll中， client不发送也不接收数据，sever一直发送数据，直到将socket 发送缓冲区打满，打满之后server再也不会发送数据。 此时client 开始连续接收n次数据（不发送数据）， 此时server又会产生EPOLLOUT，因为发送缓冲区变成可写（由满->不满）。

输出数据：

代码：

服务端代码：

2. #include <stdio.h>

3. #include <stdlib.h>

4. #include <string.h>

5. #include <strings.h>

6. #include <unistd.h>

7. #include <fcntl.h>

8. #include <errno.h>

9. #include <netinet/in.h>

10. #include <arpa/inet.h>

11. #include <sys/socket.h>

12. #include <sys/epoll.h>

15. #define SERVPORT 9527

16. #define MAXBUF 1024*1024 //1MB

17. #define MAXFDS 5000

18. #define EVENTSIZE 100

20. int setnonblocking(int fd)

21. {

22. int opts;

23. if( (opts = fcntl(fd, F_GETFL, 0)) == -1)

24. {

25. perror("fcntl");

26. return -1;

27. }

29. opts = opts | O_NONBLOCK;

30. if( (opts = fcntl(fd, F_SETFL, opts)) == -1)

31. {

32. perror("fcntl");

33. return -1;

34. }

36. return 0;

37. }

39. int main(void)

40. {

41. int len = 0, n = 0, once = 0;

42. int hasSend;

43. char buf[MAXBUF] = {0};

44. char sndMsg[MAXBUF] = {1};

46. struct sockaddr_in servaddr;

47. int sockfd, listenfd, epollfd, nfds;

49. struct epoll_event ev;

50. struct epoll_event events[EVENTSIZE];

52. bzero(&servaddr, sizeof(servaddr));

53. servaddr.sin_family = AF_INET;

54. servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

55. servaddr.sin_port = htons(SERVPORT);

57. if( (epollfd = epoll_create(MAXFDS)) == -1) {

58. perror("epoll");

59. exit(1);

60. }

62. if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

63. perror("socket");

64. exit(1);

65. }

67. if(setnonblocking(listenfd) == -1) {

68. perror("setnonblocking");

69. exit(1);

70. }

72. if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {

73. perror("bind");

74. exit(1);

75. }

77. if(listen(listenfd, 10) == -1) {

78. perror("listen");

79. exit(1);

80. }

83. ev.events = EPOLLIN | EPOLLET;

84. ev.data.fd = listenfd;

85. if(epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {

86. perror("epoll_ctl");

87. exit(1);

88. }

90. for( ; ; ) {

91. if( (nfds = epoll_wait(epollfd, events, EVENTSIZE, -1)) == -1) {

92. perror("epoll_wait");

93. exit(1);

94. }

96. for(n = 0; n < nfds; n++) {

97. if(events[n].data.fd == listenfd) {

98. while( (sockfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) > 0) {

99. if(setnonblocking(sockfd) == -1) {

100. perror("setnonblocking");

101. exit(1);

102. }

103. ev.events = EPOLLIN | EPOLLOUT | EPOLLET;

104. ev.data.fd = sockfd;

105. int nSendBuf = 4096; //上层应用设置成4096 但是底层内核实际是4096*2 = 8192

106. socklen_t opt_len = sizeof(int);

107. int ret = setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &nSendBuf, sizeof(int));

108. if (ret == -1) {

109. perror("setsockopt");

110. }

111. getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &nSendBuf, &opt_len);

112. printf("SndBuf-new = %d\n", nSendBuf);

113. if(epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev) == -1)

114. {

115. perror("epoll_ctl");

116. exit(1);

117. } else {

118. printf("new socketfd = %d register epoll success\n", sockfd);

119. }

120. }

121. continue;

122. }

124. printf("Events = 0x%x\n", events[n].events);

125. if (events[n].events & EPOLLIN && events[n].events & EPOLLOUT) {

126. printf(">> EPOLLIN And EPOLLOUT event， socketfd = %d\n", events[n].data.fd);

127. len = recv(events[n].data.fd, buf, MAXBUF, 0);

128. len = send(events[n].data.fd, sndMsg + hasSend, MAXBUF-hasSend, 0);

129. if (len > 0) {// 说明发送成功

130. hasSend += len;

131. once = 0;

132. printf("EPOLLIN | EPOLLOUT ==》 Send ok， length = %d.\n", len);

133. } else if (len == -1) {

134. if (errno == EAGAIN) {//说明发送缓冲区已经满

135. printf("EPOLLIN | EPOLLOUT ==》 Socket SndBuf is fulled. \n");

136. }

137. } else {//出现错误

138. perror("EPOLLIN | EPOLLOUT ==》 Send failed.\n");

139. exit(-1);

140. }

141. }

142. else if (events[n].events & EPOLLIN) {

143. printf(">> Only EPOLLIN event， socketfd = %d\n", events[n].data.fd);

144. }

145. else if (events[n].events & EPOLLOUT) {

146. printf(">> Only EPOLLOUT， socketfd = %d\n", events[n].data.fd);

148. while (!once) {

149. len = send(events[n].data.fd, sndMsg + hasSend, MAXBUF-hasSend, 0);

150. if (len > 0) {// 说明发送成功

151. hasSend += len;

152. printf("Send ok， length = %d.\n", len);

153. } else if (len == -1) {

154. if (errno == EAGAIN) {//说明发送缓冲区已经满

155. printf(" EPOLLOUT ==》 Socket SndBuf is fulled. \n");

156. once = 1;// 以后再也不会发送数据了,保证缓冲区不会再满

157. break;

158. }

159. } else {//出现错误

160. perror(" EPOLLOUT ==》 Send failed.\n");

161. exit(-1);

162. }

163. }

164. }

165. }

166. }

167. }

客户端代码：

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <strings.h>

5. #include <unistd.h>

6. #include <fcntl.h>

7. #include <errno.h>

8. #include <netinet/in.h>

9. #include <arpa/inet.h>

10. #include <sys/socket.h>

11. #include <sys/epoll.h>

13. #define SERVPORT 9527

14. #define MAXBUF 4096

16. int setnonblocking(int fd)

17. {

18. int opts;

19. if( (opts = fcntl(fd, F_GETFL, 0)) == -1)

20. {

21. perror("fcntl");

22. return -1;

23. }

25. opts = opts | O_NONBLOCK;

26. if( (opts = fcntl(fd, F_SETFL, opts)) == -1)

27. {

28. perror("fcntl");

29. return -1;

30. }

32. return 0;

33. }

35. int main(void)

36. {

37. char buf[MAXBUF];

38. struct sockaddr_in servaddr;

39. int fd;

40. int n, len;

42. bzero(&servaddr, sizeof(servaddr));

43. servaddr.sin_family = AF_INET;

44. servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

45. servaddr.sin_port = htons(SERVPORT);

47. if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)

48. {

49. perror("socket");

50. exit(1);

51. }

53. int nSendBuf = 0;

54. socklen_t opt_len = sizeof(int);

55. nSendBuf = 3072;

56. int ret = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &nSendBuf, sizeof(int));

57. if (ret == -1) {

58. perror("setsockopt");

59. }

61. getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &nSendBuf, &opt_len);

62. printf("Client recvbuf len = %d\n", nSendBuf);

64. if (connect(fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)

65. {

66. perror("connect");

67. exit(1);

68. }

69. setnonblocking(fd); //设置成非阻塞

70. printf("Connection ok, sleep 10s\n");

71. sleep(10); //睡眠10秒保证 服务端缓冲区被打满

72. int i = 0;

73. while(1) {

74. len = recv(fd, buf, MAXBUF, 0);

75. if (len > 0) {

76. n += len;

77. printf("第%d次，recv len = %d\n", ++i, len);

78. sleep(10);

79. } else if (len == -1 && errno == EAGAIN) {

80. printf("EAGAIN\n", n);

81. sleep(20);

82. break;//默认读取完毕

83. } else {

84. printf("Recv failed.\n");

85. exit(-1);

86. }

87. }

88. printf("close\n");

89. close(fd);

90. return 0;

91. }

三、建议

1、对于服务端listen socket不需要将EPOLLOUT注册到epoll事件模型中。因为listen socket只是负责接收数据（接收客户端建立连接请求），不会发送数据，所以不需要注册时EPOLLOUT。

2、按需注册EPOLLOUT。当我们调用send接口时，如果返回的-1且errno=EAGAIN时，再注册EPOLLOUT，后续send发送成功后，再将EPOLLOUT从epoll事件模型中移除，这就是按需注册EPOLLOUT。当然我们也可以不用移除，只不过需要判断是否真的有数据需要发送。大名鼎鼎的nginx的做法是：发送完成后会将发送的回调函数设置成一个空函数（这个函数只是定义里面什么都没有做）。nginx为什么不移除呢？因为反复添加、移除EPOLLOUT性能不友好，总是在用户层和内核层来回切换。

(62条消息) 简约而不简单epoll之EPOLLOUT_程序员的世界-CSDN博客_epollout