java epoll nio_Java NIO(7): Epoll版的Selector

Java NIO的核心部分，我已经讲完了，接下来再用几节课把java.nio这个package里一些还算有价值的地方讲一下。

本节课是小密圈《进击的Java新人》的十七周第三课。

上一节课，我们在讲到这几行代码：

jdk/src/solaris/classes/sun/nio/ch/DefaultSelectorProvider.java

public static SelectorProvider create() {

String osname = AccessController

.doPrivileged(new GetPropertyAction("os.name"));

if (osname.equals("SunOS"))

return createProvider("sun.nio.ch.DevPollSelectorProvider");

if (osname.equals("Linux"))

return createProvider("sun.nio.ch.EPollSelectorProvider");

return new sun.nio.ch.PollSelectorProvider();

}

可以看到，如果osname是Linux的话，实际上真正创建的是EPollSelectorProvider。因为在Java NIO(5): IO多路复用，这篇文章里我先介绍的是poll，所以我就把EpollSelectorProvider给绕开了。今天补一下这部分的内容。

我们继续看jdk/src/solaris/classes/sun/nio/ch/EPollSelectorProvider.java里的打开selector的定义：

public AbstractSelector openSelector() throws IOException {

return new EPollSelectorImpl(this);

}

OK，再去看EPollSelectorImpl的实现，这里面和昨天讲的PollSelectorImpl的实现十分相似，我就不再贴代码了。自己一定要打开源文件自己去看，我这里只是带着你浏览源码，充当向导，真正去学习去领悟还是要靠自己动手。

EPollSelectorImpl(SelectorProvider sp) throws IOException {

// 其他代码略，这里最重要的是初始化pollWrapper

try {

pollWrapper = new EPollArrayWrapper();

pollWrapper.initInterrupt(fd0, fd1);

fdToKey = new HashMap<>();

} catch (Throwable t) {

/* ... */

}

}

EpollSelectorImpl里最重要的方法是doSelect，这个方法与我们上节课所讲的方法大致相同，所以我就跳过这一步了，直接看pollWrapper.poll的实现。

int poll(long timeout) throws IOException {

updateRegistrations();

updated = epollWait(pollArrayAddress, NUM_EPOLLEVENTS, timeout, epfd);

for (int i=0; i

if (getDescriptor(i) == incomingInterruptFD) {

interruptedIndex = i;

interrupted = true;

break;

}

}

return updated;

}

而epollWait又是一个native方法，OK，我们去看它的实现。代码位于

jdk/src/solaris/native/sun/nio/ch/EPollArrayWrapper.c

JNIEXPORT jint JNICALL

Java_sun_nio_ch_EPollArrayWrapper_epollWait(JNIEnv *env, jobject this,

jlong address, jint numfds,

jlong timeout, jint epfd)

{

struct epoll_event *events = jlong_to_ptr(address);

int res;

if (timeout <= 0) { /* Indefinite or no wait */

RESTARTABLE(epoll_wait(epfd, events, numfds, timeout), res);

} else { /* Bounded wait; bounded restarts */

res = iepoll(epfd, events, numfds, timeout);

}

if (res < 0) {

JNU_ThrowIOExceptionWithLastError(env, "epoll_wait failed");

}

return res;

}

这里出现了一个新的东西：epoll，看JDK代码就先到这里。我来讲一下epoll是什么东西。

使用EPoll

上节课介绍的poll方法有一个非常大的缺陷。poll 函数的返回值是一个整数，得到了这个返回值以后，我们还是要逐个去检查，比如说，有一万个socket同时poll，返回值是3，我们还是只能去遍历这一万个socket，看看它们是否有IO动作。这就很低效了，于是，就有了epoll的改进，epoll可以直接通过“输出参数”(可以理解为C语言中的指针类型的参数)，一个 epoll_event 数组，直接获得这三个socket，这就比较快了。

来具体讲一下，epoll的接口包括三个函数：

1. int epoll_create(int size);

创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

epoll的事件注册函数。

第一个参数是epoll_create()的返回值，

第二个参数表示动作，用三个宏来表示：

EPOLL_CTL_ADD：注册新的fd到epfd中；

EPOLL_CTL_MOD：修改已经注册的fd的监听事件；

EPOLL_CTL_DEL：从epfd中删除一个fd；

第三个参数是需要监听的fd，就是我们的socket

第四个参数是告诉内核需要监听什么事，struct epoll_event结构如下：

typedef union epoll_data {

void *ptr;

int fd;

__uint32_t u32;

__uint64_t u64;

} epoll_data_t;

struct epoll_event {

__uint32_t events; /* Epoll events */

epoll_data_t data; /* User data variable */

};

events可以是以下几个宏的集合：(这是最常见的三种，其他很少用到，我就先不贴了)

EPOLLIN ：表示对应的文件描述符可以读(包括对端SOCKET正常关闭)；

EPOLLOUT：表示对应的文件描述符可以写；

EPOLLERR：表示对应的文件描述符发生错误；

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

等待事件的产生。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个 maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间(毫秒，0会立即返回，-1是永久阻塞)。该函数返回需要处理的事件数目，如返回0表示已超时。

相比起poll，其实就多了一个 epdf 的结构和 epoll_ctl 而已。其他的主要逻辑都是一样的，所以 poll 的服务端例子，可以这样改写：

#include #include #include #include #include #include #include #include #include #include

#define MAX_FD_NUM 1024#define MAXLEN 1024

int buf_len = 0;

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

{

int i = 0;

printf("server start up\n");

if(argc <= 2)

{

printf("usage:%s ip port\n",basename(argv[0]));

return 1;

}

const char* ip = argv[1];

int port = atoi(argv[2]);

int server_sockfd = socket(PF_INET,SOCK_STREAM,0);

struct sockaddr_in server_addr;

bzero(&server_addr, sizeof(server_addr));

server_addr.sin_family = AF_INET;

inet_pton(AF_INET, ip, &server_addr.sin_addr);

server_addr.sin_port = htons(port);

int ret = bind(server_sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));

assert(ret != -1);

ret = listen(server_sockfd, MAX_FD_NUM - 1);

assert(ret != -1);

struct sockaddr_in client_addr;

socklen_t client_addr_len = sizeof(struct sockaddr_in);

// 创建一个 epfd，并且把 server_sockfd 注册到这个 epfd上。 int epfd = epoll_create(1024);

struct epoll_event ev,events[20];

ev.data.fd = server_sockfd;

ev.events = EPOLLIN;

epoll_ctl(epfd, EPOLL_CTL_ADD, server_sockfd, &ev);

int cur_fd_num = 1;

char buf[MAXLEN]={0};

while (1) {

// nReady 就是 events 数组的长度。 int nready = epoll_wait(epfd, events, 20, 50);

int i = 0;

for (; i < nready; i++) {

if (events[i].data.fd == server_sockfd) {

int client_sockfd = accept(server_sockfd,(struct sockaddr*)&client_addr,&client_addr_len);

if(client_sockfd < 0) {

perror("accept");

}

else {

printf("accept client_addr %s\n",inet_ntoa(client_addr.sin_addr));

ev.data.fd = client_sockfd;

ev.events=EPOLLIN;

epoll_ctl(epfd, EPOLL_CTL_ADD, client_sockfd, &ev);

}

}

else if (events[i].events & EPOLLIN) {

int connfd = events[i].data.fd;

int n = recv(connfd, buf, MAXLEN, 0);

if(n < 0) {

if(ECONNRESET == errno) {

close(connfd);

epoll_ctl(epfd, EPOLL_CTL_DEL, connfd, 0);

}

else {

perror("recv");

}

}

printf("receive %s", buf);

buf_len = n;

ev.data.fd = connfd;

ev.events = EPOLLOUT;

epoll_ctl(epfd, EPOLL_CTL_MOD, connfd, &ev);

}

else if (events[i].events & EPOLLOUT) {

int connfd = events[i].data.fd;

write(connfd, buf, buf_len);

ev.data.fd = connfd;

ev.events = EPOLLIN;

epoll_ctl(epfd, EPOLL_CTL_MOD, connfd, &ev);

}

}

}

return 0;

}

OK，我们这个服务端的逻辑与之前poll的，或者是Java的 Selector 的例子是完全等价的。好了，今天关于Epoll就讲解这么多了。

习题：

EpollArrayWrapper.java还有很多点，我没有涉及，例如，pollArray和pollArrayAddress是怎么回事，epollCtl 和 epollCreate 都是在什么时候调用的，这些问题，自己去看看代码，搞清楚。