先写个简单的例子

// 开启一个server channel来监听
ServerSocketChannel ssc = ServerSocketChannel.open();
// 开启非阻塞模式
ssc.configureBlocking(false);
ServerSocket socket = ssc.socket();
socket.bind(new InetSocketAddress("localhost",65535));//绑定相应IP及port
//ssc.bind(new InetSocketAddress("localhost",65535));
Selector selector = Selector.open();//开启一个selector
ssc.register(selector,SelectionKey.OP_ACCEPT);//绑定注册事件

while(true){
this.selector.select();//阻塞,只有当至少一个注册的事件发生的时候才会继续.
Set<SelectionKey> selectKeys = this.selector.selectedKeys();
Iterator<SelectionKey> it = selectKeys.iterator();
  while (it.hasNext()) {
    SelectionKey key = it.next();
    it.remove();
    // 处理事件. 可以用多线程来处理.
    this.dispatch(key);
  }
} 

OK，我们一句一句来看

第一句

ServerSocketChannel ssc = ServerSocketChannel.open();

public static ServerSocketChannel open() throws IOException {
    return SelectorProvider.provider().openServerSocketChannel();
}

这里会根据操作系统得到不同的provider，由于用的是mac，而且一般服务器以linux为主，所以这边返回的是EPollSelectorProvider

进一步SelectorProviderImpl中：

 public ServerSocketChannel openServerSocketChannel() throws IOException {
    return new ServerSocketChannelImpl(this);
}

ServerSocketChannelImpl(SelectorProvider sp) throws IOException {
    super(sp);//这里面可以不看，就是SelectorProvider的赋值
    this.fd =  Net.serverSocket(true);
    this.fdVal = IOUtil.fdVal(fd);//这2句都是native操作，没有看底层的jvm源码，看函数名应该是新建FD并进行赋值
    this.state = ST_INUSE;
    }

第二句

ssc.configureBlocking(false);

这句不展开了，看名字就知道开启非阻塞模式
底层调用了

static native void configureBlocking(FileDescriptor fd, boolean blocking)
    throws IOException;

第三句

ServerSocket socket = ssc.socket();
socket.bind(new InetSocketAddress("localhost",65535));

看ServerSocketChannelImpl中：

public ServerSocket socket() {
    synchronized (stateLock) {
        if (socket == null)
            socket = ServerSocketAdaptor.create(this);//这里只是新建了一个适配器，本质上还是ssc
        return socket;
    }
 }

具体绑定过程：

public void bind(SocketAddress local, int backlog) throws IOException {
    if (local == null)
        local = new InetSocketAddress(0);
    try {
        ssc.bind(local, backlog);//如上所述，本质上还是ssc
    } catch (Exception x) {
        Net.translateException(x);
    }
}

所以我试了下

ssc.bind(new InetSocketAddress("localhost",65535));

也是可以的

第四句

Selector selector = Selector.open();//开启一个selector

一步一步看：

 public static Selector open() throws IOException {
    return SelectorProvider.provider().openSelector();//这里返回的是EPollSelectorImpl
}

在EPollSelectorProvider中：

public AbstractSelector openSelector() throws IOException {
    return new EPollSelectorImpl(this);
}

第五句

ssc.register(selector, SelectionKey.OP_ACCEPT);

这里一步步跟下去，最终是在AbstractSelectableChannel：

public final SelectionKey register(Selector sel, int ops,
                                   Object att)
    throws ClosedChannelException
{
    if (!isOpen())
        throw new ClosedChannelException();
    if ((ops & ~validOps()) != 0)//下面的代码块中注明，这里只支出accept行为的注册
        throw new IllegalArgumentException();
    synchronized (regLock) {
        if (blocking)
            throw new IllegalBlockingModeException();
        SelectionKey k = findKey(sel);//查找sel是否已经绑定对应的key了，具体代码这里不贴
        if (k != null) {
            k.interestOps(ops);//这句后面再讲，有多处调用到
            k.attach(att);//这里的attachment为null，一般可以用于保存session等作为有状态通讯
        }
        if (k == null) {
            // New registration
            k = ((AbstractSelector)sel).register(this, ops, att);//这句在下面解释
            addKey(k);//这句就是加到保存的SelectionKey[]全局变量
        }
        return k;
    }
}

ServerSocketChannel中：

/*Server-socket channels only support the accepting of new
 * connections, so this method returns {@link SelectionKey#OP_ACCEPT}.*/
public final int validOps() {
    return SelectionKey.OP_ACCEPT;
}

SelectorImpl：

protected final SelectionKey register(AbstractSelectableChannel ch,
                                      int ops,
                                      Object attachment)
{
    if (!(ch instanceof SelChImpl))
        throw new IllegalSelectorException();
    SelectionKeyImpl k = new SelectionKeyImpl((SelChImpl)ch, this);//新建key,这个ch就是最初的ssc
    k.attach(attachment);
    synchronized (publicKeys) {
        implRegister(k);//主要是这个
    }
    k.interestOps(ops);
    return k;
}

再看EPollSelectorImpl：

protected void implRegister(SelectionKeyImpl ski) {
    if (closed)
        throw new ClosedSelectorException();
    SelChImpl ch = ski.channel;
    fdToKey.put(Integer.valueOf(ch.getFDVal()), ski);
    pollWrapper.add(ch); //这里要见最底下的图， 核心代码updateList.add(new Updator(channel, EPOLL_CTL_ADD));这个码updateList在下面interestOps会用到
    keys.add(ski);
}

再来说多处用到的k.interestOps(ops);
SelectionKeyImpl:

SelectionKey nioInterestOps(int ops) {      // package-private
    if ((ops & ~channel().validOps()) != 0)
        throw new IllegalArgumentException();
    channel.translateAndSetInterestOps(ops, this);
//这句
    interestOps = ops;
    return this;
}

SocketChannelImpl，这里讲SelectionKey对应的操作转为EPOLL对应的事件类型，具体可以查看EPOLL相关文档：

public void translateAndSetInterestOps(int ops, SelectionKeyImpl sk) {
    int newOps = 0;
    if ((ops & SelectionKey.OP_READ) != 0)
        newOps |= PollArrayWrapper.POLLIN;
    if ((ops & SelectionKey.OP_WRITE) != 0)
        newOps |= PollArrayWrapper.POLLOUT;
    if ((ops & SelectionKey.OP_CONNECT) != 0)
        newOps |= PollArrayWrapper.POLLCONN;
    sk.selector.putEventOps(sk, newOps);
}

跟踪下去EPollSelectorImpl，中间代码不贴了：

void putEventOps(SelectionKeyImpl sk, int ops) {
    if (closed)
        throw new ClosedSelectorException();
    pollWrapper.setInterest(sk.channel, ops);
}

继续EPollArrayWrapper,这里将注册事件及对应的channel保存到一个updateList中:

void setInterest(SelChImpl channel, int mask) {
    synchronized (updateList) {
        // if the previous pending operation is to add this file descriptor
        // to epoll then update its event set
        if (updateList.size() > 0) {
            Updator last = updateList.getLast();//防止已经加过了的channel直接更新事件
            if (last.channel == channel && last.opcode == EPOLL_CTL_ADD) {
                last.events = mask;
                return;
            }
        }

        // update existing registration
        updateList.add(new Updator(channel, EPOLL_CTL_MOD, mask));
    }
}

到这里为止其实初始化的工作都做好了，接下来

第六句

this.selector.select();

还是去掉中间代码，直接看核心的EPollSelectImpl：

protected int doSelect(long timeout) throws IOException
{
    if (closed)
        throw new ClosedSelectorException();
    processDeregisterQueue();//处理已经取消的key
    try {
        begin();
        pollWrapper.poll(timeout);//核心代码看下面
    } finally {
        end();
    }
    processDeregisterQueue();
    int numKeysUpdated = updateSelectedKeys(); //核心代码，见下面
    if (pollWrapper.interrupted()) { //中断处理，暂时不看
        // Clear the wakeup pipe
        pollWrapper.putEventOps(pollWrapper.interruptedIndex(), 0);
        synchronized (interruptLock) {
            pollWrapper.clearInterrupted();
            IOUtil.drain(fd0);
            interruptTriggered = false;
        }
    }
    return numKeysUpdated;
}

EPollArrayWrapper：

int poll(long timeout) throws IOException {
    updateRegistrations();  //核心代码更新前面updateList中的操作到native
    updated = epollWait(pollArrayAddress, NUM_EPOLLEVENTS, timeout, epfd); //核心代码，执行native的epollWait方法，等待注册事件上来
    for (int i=0; i<updated; i++) {
        if (getDescriptor(i) == incomingInterruptFD) {
            interruptedIndex = i;
            interrupted = true;
            break;
        }
    }
    return updated;
}

//这个函数就是遍历前缓存的所有注册时间的updateList，去掉闲置的，执行native的epollCtl方法
void updateRegistrations() {
    synchronized (updateList) {
        Updator u = null;
        while ((u = updateList.poll()) != null) {
            SelChImpl ch = u.channel;
            if (!ch.isOpen())
                continue;

            // if the events are 0 then file descriptor is put into "idle
            // set" to prevent it being polled
            if (u.events == 0) {
                boolean added = idleSet.add(u.channel);
                // if added to idle set then remove from epoll if registered
                if (added && (u.opcode == EPOLL_CTL_MOD)) //如果是闲置的，删除
                    epollCtl(epfd, EPOLL_CTL_DEL, ch.getFDVal(), 0);
            } else {
                // events are specified. If file descriptor was in idle set
                // it must be re-registered (by converting opcode to ADD)
                boolean idle = false;
                if (!idleSet.isEmpty())
                    idle = idleSet.remove(u.channel);
                int opcode = (idle) ? EPOLL_CTL_ADD : u.opcode;
                epollCtl(epfd, opcode, ch.getFDVal(), u.events);
            }
        }
    }
}

//更新SelectedKeys给后面的this.selector.selectedKeys();使用
private int updateSelectedKeys() {
    int entries = pollWrapper.updated;
    int numKeysUpdated = 0;
    for (int i=0; i<entries; i++) {
        int nextFD = pollWrapper.getDescriptor(i);
        SelectionKeyImpl ski = fdToKey.get(Integer.valueOf(nextFD));
        // ski is null in the case of an interrupt
        if (ski != null) {
            int rOps = pollWrapper.getEventOps(i);
            if (selectedKeys.contains(ski)) {
                if (ski.channel.translateAndSetReadyOps(rOps, ski)) {
                    numKeysUpdated++;
                }
            } else {
                ski.channel.translateAndSetReadyOps(rOps, ski);//这句处理返回的ops，过滤掉异常的操作等，可以结合IO模式中的epoll_ctl事件类型查看
                if ((ski.nioReadyOps() & ski.nioInterestOps()) != 0) {
                    selectedKeys.add(ski);
                    numKeysUpdated++;
                }
            }
        }
    }
    return numKeysUpdated;
}

最后：

Set<SelectionKey> selectKeys = this.selector.selectedKeys();
Iterator<SelectionKey> it = selectKeys.iterator();
  while (it.hasNext()) {
    SelectionKey key = it.next();
    it.remove();
    // 处理事件. 可以用多线程来处理.
    this.dispatch(key);
  }
} 

这里就很简单了，selectedKeys()已经在上一步处理好了，这里只是拿出来做相应的业务操作

这样一个服务端的启动操作就完成了，后面还要注册SocketChannel的读写事件，就到以后再分析。
Epoll相关内容以前写过，就不写了。

整个epoll的类关系图：

epoll.png