netty支持的各种socketchannel实现及比较
性能上从低到高如下：
- OioSocketChannel：传统，阻塞式编程。
- NioSocketChannel：select/poll或者epoll，jdk 7之后linux下会自动选择epoll。epoll原理及与select/poll的伸缩性性能测试基准
- EpollSocketChannel：epoll，仅限linux，提供更多额外选项。
- EpollDomainSocketChannel：ipc模式，仅限客户端、服务端在相同主机的情况，从4.0.26版本开始支持，见https://github.com/netty/netty/pull/3344。
select示例（监听标准输入）
#include <stdio.h> #include <stdlib.h> #include <sys/select.h> int main(void) { int retval; fd_set rfds; struct timeval tv; /* Wait up to five seconds. */ tv.tv_sec = 5; tv.tv_usec = 0; // 每次都需要重置，限制1024 /* Watch stdin (fd 0) to see when it has input. */ FD_ZERO(&rfds); FD_SET(0, &rfds); retval = select(1, &rfds, NULL, NULL, &tv); /* Don't rely on the value of tv now! */ if (retval == -1) perror("select()"); else if (retval) { printf("Data is available now.\n"); printf("%d\n",FD_ISSET(0,&rfds)); /* FD_ISSET(0, &rfds) will be true. */ } else printf("No data within five seconds.\n"); exit(EXIT_SUCCESS); }
poll示例（监听文件修改）
/* poll_input.c Licensed under GNU General Public License v2 or later. */ #include <fcntl.h> #include <poll.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <malloc.h> #include <string.h> #define errExit(msg) do { perror(msg); exit(EXIT_FAILURE); \ } while (0) // 从文件读取，文件写入内容后会读取最新的内容，适合于日志监听 int main(int argc, char *argv[]) { int ready; char buf[10]; nfds_t num_open_fds, nfds; ssize_t s; struct pollfd *pfds; if (argc < 2) { fprintf(stderr, "Usage: %s file...\n", argv[0]); exit(EXIT_FAILURE); } num_open_fds = nfds = argc - 1; pfds = (pollfd *)calloc(nfds, sizeof(struct pollfd)*num_open_fds); if (pfds == NULL) errExit("malloc"); /* Open each file on command line, and add it to 'pfds' array. */ char err_msg[256] = {}; for (nfds_t j = 0; j < nfds; j++) { pfds[j].fd = open(argv[j + 1], O_RDONLY); if (pfds[j].fd == -1) { memset(err_msg, 0, sizeof(err_msg)); snprintf(err_msg,256,"open %s failed",argv[j+1]); errExit(err_msg); } printf("Opened \"%s\" on fd %d\n", argv[j + 1], pfds[j].fd); pfds[j].events = POLLIN; } /* Keep calling poll() as long as at least one file descriptor is open. */ while (num_open_fds > 0) { printf("About to poll()\n"); ready = poll(pfds, nfds, -1); if (ready == -1) errExit("poll"); printf("Ready: %d\n", ready); /* Deal with array returned by poll(). */ for (nfds_t j = 0; j < nfds; j++) { if (pfds[j].revents != 0) { printf(" fd=%d; events: %s%s%s\n", pfds[j].fd, (pfds[j].revents & POLLIN) ? "POLLIN " : "", (pfds[j].revents & POLLHUP) ? "POLLHUP " : "", (pfds[j].revents & POLLERR) ? "POLLERR " : ""); if (pfds[j].revents & POLLIN) { s = read(pfds[j].fd, buf, sizeof(buf)); if (s == -1) errExit("read"); printf(" read %zd bytes: %.*s\n", s, (int) s, buf); } else { /* POLLERR | POLLHUP */ printf(" closing fd %d\n", pfds[j].fd); if (close(pfds[j].fd) == -1) errExit("close"); num_open_fds--; } } } sleep(5); } printf("All file descriptors closed; bye\n"); exit(EXIT_SUCCESS); }
pollin模拟简单，客户端输入即可。pollout呢？可以看下这里。
poll监听socket
#include <stdio.h> #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h> #include <string.h> #include <unistd.h> #include <assert.h> #include <signal.h> #include <stdlib.h> #include <stdio.h> #include <errno.h> #include <poll.h> // https://blog.csdn.net/fengasdfgh/article/details/64920120 int start_up(sockaddr_in &addr) { int socketi = socket(PF_INET, SOCK_STREAM, 0); printf("%d\n", socketi); if (socketi < 0) { printf("%d, %s", errno, strerror(errno)); exit(1); } int flag = bind(socketi, (sockaddr *)&addr, sizeof(addr)); if (flag < 0) { printf("%d, %s", errno, strerror(errno)); exit(2); } flag = listen(socketi, 5); if (flag < 0) { printf("%d, %s", errno, strerror(errno)); exit(2); } return socketi; } int main(int argc, char *argv[]) { if (argc < 3) { printf("can sgu error"); exit(0); } struct sockaddr_in addr; bzero(&addr, sizeof(addr)); addr.sin_addr.s_addr = inet_addr(argv[1]); addr.sin_port = htons(atoi(argv[2])); addr.sin_family = PF_INET; int socketi = start_up(addr); / // printf("%d\n", socketi); char fd[100] = {0}; // memset(&fd, sizeof(fd), -1); struct pollfd pfd[100]; pfd[0].fd = socketi; pfd[0].events = POLLIN; for (int i = 1; i < 100; i++) { pfd[i].fd = -1; } /// int flag = 1; int max = socketi; char buf[100] = {0}; socklen_t len = sizeof(addr); for (;;) { int timeout = 5000; if (false == flag) { max = 0; for (int i = 1; i < 100; i++) { if (pfd[i].fd > max) max = pfd[i].fd; } } int ret = poll(pfd, max + 1, timeout); if (pfd[0].revents & POLLIN) { struct sockaddr_in client; socklen_t client_len = sizeof(client); int connfd = accept(socketi, (struct sockaddr *)&client, &client_len); if (connfd < 0) { printf("%d, %s\n", errno, strerror(errno)); } for (int i = 1; i < 100; i++) { if (pfd[i].fd < 0) { pfd[i].fd = connfd; max++; break; } } if (connfd > max) max = connfd; } for (int i = 1; i < 100; i++) { if (pfd[i].fd > 0 && (pfd[i].revents & POLLIN)) { ssize_t size = read(pfd[i].fd, buf, 20); if (size <= 0) { printf("client is quit\n"); pfd[i].fd = -1; if (pfd[i].fd == max) flag = false; continue; } buf[size - 1] = 0; printf("client:%s\n", buf); } } } return 0; }
epoll示例
#define MAX_EVENTS 5 #define READ_SIZE 10 #include <stdio.h> // for fprintf() #include <unistd.h> // for close(), read() #include <sys/epoll.h> // for epoll_create1(), epoll_ctl(), struct epoll_event #include <string.h> // for strncmp int main() { int running = 1, event_count, i; size_t bytes_read; char read_buffer[READ_SIZE + 1]; struct epoll_event event, events[MAX_EVENTS];
// epoll_create1(EPOLL_CLOEXEC) 是一个用于创建 epoll 实例的系统调用，它用于异步事件通知。EPOLL_CLOEXEC 是一个标志，它告诉操作系统在创建 epoll 实例时将其设置为 close-on-exec（CLOEXEC）模式。
在 CLOEXEC 模式下，当一个进程调用 fork() 创建子进程或调用 exec() 执行一个新程序时，内核会自动关闭 epoll 实例，以防止在子进程或新程序中泄漏 epoll 文件描述符。这是一种安全措施，确保 epoll 文件描述符不会在不应该的地方被误用。 int epoll_fd = epoll_create1(EPOLL_CLOEXEC); if (epoll_fd == -1) { fprintf(stderr, "Failed to create epoll file descriptor\n"); return 1; } event.events = EPOLLIN; event.data.fd = 0; if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, 0, &event)) { fprintf(stderr, "Failed to add file descriptor to epoll\n"); close(epoll_fd); return 1; } while (running) { printf("\nPolling for input...\n"); event_count = epoll_wait(epoll_fd, events, MAX_EVENTS, 30000); printf("%d ready events\n", event_count); for (i = 0; i < event_count; i++) { printf("Reading file descriptor '%d' -- ", events[i].data.fd); bytes_read = read(events[i].data.fd, read_buffer, READ_SIZE); printf("%zd bytes read.\n", bytes_read);
// trim last \n from stdin
read_buffer[bytes_read-1] = '\0'; printf("Read '%s'\n", read_buffer); if(!strncmp(read_buffer, "stop\n", 5)) running = 0; } } if (close(epoll_fd)) { fprintf(stderr, "Failed to close epoll file descriptor\n"); return 1; } return 0; }
epoll各种事件的含义（man手册和头文件没有枚举）
The events member is a bit mask composed by ORing together zero or more of the following
available event types:
EPOLLIN
The associated file is available for read(2) operations.
EPOLLOUT
The associated file is available for write(2) operations.
EPOLLRDHUP (since Linux 2.6.17)
Stream socket peer closed connection, or shut down writing half of connection.
(This flag is especially useful for writing simple code to detect peer shutdown
when using Edge Triggered monitoring.)
EPOLLPRI
There is an exceptional condition on the file descriptor. See the discussion of
POLLPRI in poll(2).
EPOLLERR
Error condition happened on the associated file descriptor. This event is also
reported for the write end of a pipe when the read end has been closed.
epoll_wait(2) will always report for this event; it is not necessary to set it in
events.
EPOLLHUP
Hang up happened on the associated file descriptor. epoll_wait(2) will always wait
for this event; it is not necessary to set it in events.
Note that when reading from a channel such as a pipe or a stream socket, this event
merely indicates that the peer closed its end of the channel. Subsequent reads
from the channel will return 0 (end of file) only after all outstanding data in the
channel has been consumed.
EPOLLET
Sets the Edge Triggered behavior for the associated file descriptor. The default
behavior for epoll is Level Triggered. See epoll(7) for more detailed information
about Edge and Level Triggered event distribution architectures.
EPOLLONESHOT (since Linux 2.6.2)
Sets the one-shot behavior for the associated file descriptor. This means that
after an event is pulled out with epoll_wait(2) the associated file descriptor is
internally disabled and no other events will be reported by the epoll interface.
The user must call epoll_ctl() with EPOLL_CTL_MOD to rearm the file descriptor with
a new event mask.
EPOLLWAKEUP (since Linux 3.5)
If EPOLLONESHOT and EPOLLET are clear and the process has the CAP_BLOCK_SUSPEND
capability, ensure that the system does not enter "suspend" or "hibernate" while
this event is pending or being processed. The event is considered as being
"processed" from the time when it is returned by a call to epoll_wait(2) until the
next call to epoll_wait(2) on the same epoll(7) file descriptor, the closure of
that file descriptor, the removal of the event file descriptor with EPOLL_CTL_DEL,
or the clearing of EPOLLWAKEUP for the event file descriptor with EPOLL_CTL_MOD.
See also BUGS.
EPOLLEXCLUSIVE (since Linux 4.5)
Sets an exclusive wakeup mode for the epoll file descriptor that is being attached
to the target file descriptor, fd. When a wakeup event occurs and multiple epoll
file descriptors are attached to the same target file using EPOLLEXCLUSIVE, one or
more of the epoll file descriptors will receive an event with epoll_wait(2). The
default in this scenario (when EPOLLEXCLUSIVE is not set) is for all epoll file
descriptors to receive an event. EPOLLEXCLUSIVE is thus useful for avoiding
thundering herd problems in certain scenarios.
If the same file descriptor is in multiple epoll instances, some with the
EPOLLEXCLUSIVE flag, and others without, then events will be provided to all epoll
instances that did not specify EPOLLEXCLUSIVE, and at least one of the epoll
instances that did specify EPOLLEXCLUSIVE.
The following values may be specified in conjunction with EPOLLEXCLUSIVE: EPOLLIN,
EPOLLOUT, EPOLLWAKEUP, and EPOLLET. EPOLLHUP and EPOLLERR can also be specified,
but this is not required: as usual, these events are always reported if they occur,
regardless of whether they are specified in events. Attempts to specify other
values in events yield the error EINVAL.
EPOLLEXCLUSIVE may be used only in an EPOLL_CTL_ADD operation; attempts to employ
it with EPOLL_CTL_MOD yield an error. If EPOLLEXCLUSIVE has been set using
epoll_ctl(), then a subsequent EPOLL_CTL_MOD on the same epfd, fd pair yields an
error. A call to epoll_ctl() that specifies EPOLLEXCLUSIVE in events and specifies
the target file descriptor fd as an epoll instance will likewise fail. The error
in all of these cases is EINVAL.
总结
| select | poll | epoll | |
| 文件描述符限制 | 1024 | 65536 | 无限制 |
| 每次需要重新设置监听对象和事件 | 是 | 否 | 否 |
| 找到变化的对象 |
当数据准备好后，select需要再次遍历表，找出准备好的文件描述符，效率低 O(n) |
当数据准备好之后，poll需要遍历表，找出准备好的文件描述符，效率低 O(n) |
当数据准备好之后，epoll直接能够找出准备好的文件描述符，不需要遍历表，效率高 O(1) |
| 适用场景 |
socket活跃，连接数一两千 |
socket活跃，连接数一两千 |
大量socket，活跃比例低，如http长连接 |
| 工作模式 |
LT |
LT |
LT ET |
| 阻塞与否 |
轮训同步阻塞 |
轮训同步阻塞，性能和select差不多，唯一的就是句柄数多 |
异步模式，但也是在epoll_wait上等待。 |
服务器软件如postgresql中select/poll/epoll一般都有在使用，监听事件用poll和epoll居多，select主要是历史原因，网络编程用的多。
关于unix domain socket的详细解释，可参考：
http://blog.csdn.net/guxch/article/details/7041052
关于epoll/poll/select的白话文解释，可参考：
https://my.oschina.net/dclink/blog/287198
epoll用法以及帮助手册：
http://man7.org/linux/man-pages/man7/epoll.7.html
http://blog.chinaunix.net/uid-311680-id-2439723.html
http://www.tuicool.com/articles/y6je2yf
https://zhuanlan.zhihu.com/p/373835207
http://www.tuicool.com/articles/mQ3iAr
关于epoll模式下连接的超时时间设置可参考：
http://stackoverflow.com/questions/6590531/how-do-i-implement-epoll-timeout
