深度解析Java NIO底层实现原理（serverSocketChannel注册到Selector）

深碍√TFBOYSˉ_ 2022-10-11 15:58 186阅读 0赞

> 原创不易，转载请注明出处

### 文章目录 ###

*   *   *  前言
         *  ServerSocketChannel注册源码分析
         *  总结

--------------------

### 前言 ###

在上面之前的文章中我们剖析了ServerSocketChannel\#open 与Selector\#open的底层原理。本文接着之前的深度解析Java NIO底层实现原理系列文章往下介绍，看看`serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);`这行代码的底层实现原理，也就是看看serversocketChannel是怎样注册到selector上面的，主要都干了些啥。

### ServerSocketChannel注册源码分析 ###

serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

public final SelectionKey register(Selector sel, int ops,
                                       Object att)
        throws ClosedChannelException
    { 
        synchronized (regLock) { 
            if (!isOpen())
                throw new ClosedChannelException();
            if ((ops & ~validOps()) != 0)
                throw new IllegalArgumentException();
            if (blocking)
                throw new IllegalBlockingModeException();
    // 先查找本地
            SelectionKey k = findKey(sel);
            if (k != null) { 
                k.interestOps(ops);
                k.attach(att);
            }
            if (k == null) { 
                // New registration
                synchronized (keyLock) { 
                    if (!isOpen())
                        throw new ClosedChannelException();
                    k = ((AbstractSelector)sel).register(this, ops, att);
                    addKey(k);
                }
            }
            return k;
        }
    }

可以看到先通过findKey方法查找缓存对应selector上的SelectionKey对象，SelectionKey你可以看作是某个channel与事件的绑定关系。  
如果SelectionKey 不是null的话，直接设置对应感兴趣的事件就可以了。  
这里稍微看下findKey方法

private SelectionKey findKey(Selector sel) { 
        synchronized (keyLock) { 
            if (keys == null)
                return null;
     // 遍历查找对应selector 那个SelectionKey
            for (int i = 0; i < keys.length; i++)
                if ((keys[i] != null) && (keys[i].selector() == sel))
                    return keys[i];
            return null;
        }
    }

可以看到其实就是遍历keys数组，然后找到对应selector的selectionKey对象  
回到register方法中  
如果本地之前没有生成过的话，就会调用selector的register方法进行注册，返回对应的selectionKey对象。  
我们重点关注`k = ((AbstractSelector)sel).register(this, ops, att);`看看selector的register方法实现。  
这里的这个selector是EPollSelectorImpl ，register方法没有，需要看下它父类SelectorImpl 的register方法

protected final SelectionKey register(AbstractSelectableChannel ch,
                                          int ops,
                                          Object attachment)
    { 
        if (!(ch instanceof SelChImpl))
            throw new IllegalSelectorException();
        SelectionKeyImpl k = new SelectionKeyImpl((SelChImpl)ch, this);
        k.attach(attachment);
        synchronized (publicKeys) { 
            implRegister(k);
        }
        k.interestOps(ops);
        return k;
    }

可以看到，就是创建了一个SelectionKeyImpl对象，将channel与selector当作构造参数传入。这个SelectionKey可以看作是channel与事件的映射类。因为它里面就是维护着channel，selector，感兴趣的事件，准备好的事件这些信息。  
接着调用了implRegister 方法，进行注册，这个implRegister方法是个抽象方法，需要子类进行实现，这里也就是EPollSelectorImpl 实现的。  
看看这个implRegister方法干了啥

protected void implRegister(SelectionKeyImpl ski) { 
        if (closed)
            throw new ClosedSelectorException();
        SelChImpl ch = ski.channel;
        int fd = Integer.valueOf(ch.getFDVal());
        fdToKey.put(fd, ski);
        pollWrapper.add(fd);
        keys.add(ski);
    }

先是获取channel对应的socket文件描述符，然后维护在fdToKey 这个map中。  
fdToKey 我们之前的文章中也说过，他就是维护 文件描述符与SelectionKey对应关系的。  
接着就是调用pollWrapper.add(fd); 方法

void add(int fd) { 
        // force the initial update events to 0 as it may be KILLED by a
        // previous registration.
        synchronized (updateLock) { 
            assert !registered.get(fd);
            setUpdateEvents(fd, (byte)0, true);
        }
    }

这里其实就是先判断下哟有没有注册，如果没有注册的话，就调用setUpdateEvents 更新下事件

private void setUpdateEvents(int fd, byte events, boolean force) { 
        if (fd < MAX_UPDATE_ARRAY_SIZE) { 
            if ((eventsLow[fd] != KILLED) || force) { 
                // 重新设置event
                eventsLow[fd] = events;
            }
        } else { 
            Integer key = Integer.valueOf(fd);
            if (!isEventsHighKilled(key) || force) { 
                eventsHigh.put(key, Byte.valueOf(events));
            }
        }
    }

可以看到，这里就是判断fd的大小，默认超过65535的话，就会放到eventsHigh这个map里面了，否则的话是放到eventsLow 数组中的，然后fd作为数组索引值或者是map的key，event作为某索引位置组或者是map的value。  
到这里EPollSelectorImpl 的implRegister方法就完事了，其实就是维护了一些数据结构数值。

接着selector的register方法往下，就到了 `k.interestOps(ops);`这行代码了，我们看下它干了些什么。

public SelectionKey interestOps(int var1) { 
        this.ensureValid();
        return this.nioInterestOps(var1);
    }
    
    
    public SelectionKey nioInterestOps(int ops) { 
        if ((ops & ~channel().validOps()) != 0)
            throw new IllegalArgumentException();
        channel.translateAndSetInterestOps(ops, this);
        interestOps = ops;
        return this;
    }

很核心的其实就是这行 `channel.translateAndSetInterestOps(ops, this);`代码，可以看到是调用了channel的translateAndSetInterestOps方法，这个方法从方法名上面就能看出来，转换跟设置感兴趣的事件。  
转换其实很简单，就是将java nio 事件转成 epoll里面的事件类型  
设置感兴趣事件，其实就是将事件注册到epoll里面，但是这里实际上并没有操作epoll，只是做了事件的保存工作。  
我们来看下这个translateAndSetInterestOps 方法。  
这个是在ServerSocketChannelImpl的

public void translateAndSetInterestOps(int ops, SelectionKeyImpl sk) \{  
int newOps = 0;  
// Translate ops  
if ((ops & SelectionKey.OP\_ACCEPT) != 0)  
newOps |= PollArrayWrapper.POLLIN;  
// Place ops into pollfd array  
sk.selector.putEventOps(sk, newOps);  
\}  
`(ops & SelectionKey.OP_ACCEPT) != 0` 这行，我们这里本来就是注册的OP\_ACCEPT事件，所以说不是0.  
`newOps |= PollArrayWrapper.POLLIN;` 如果是OP\_ACCEPT事件的话，这里的ops 就是 1000 | 0001 结果就相当于EPOLLIN | EPOLLOUT;LT模式  
下面是java nio事件

OP_READ = 1 << 0
    OP_WRITE = 1 << 2
    OP_CONNECT = 1 << 3
    OP_ACCEPT = 1 << 4

下面是epoll事件

EPOLLIN:1
    EPOLLOUT:4
    EPOLLRDHUP:8192
    EPOLLPRI:2
    EPOLLERR:8
    EPOLLHUP:16
    EPOLLET:-2147483648
    EPOLLONESHOT:1073741824

接着就是调用 `sk.selector.putEventOps(sk, newOps);`这行代码了。  
看看selector的putEventOps方法实现

public void putEventOps(SelectionKeyImpl ski, int ops) { 
        if (closed)
            throw new ClosedSelectorException();
        //获取channel
        SelChImpl ch = ski.channel;
        //为channel设置感兴趣的事件
        pollWrapper.setInterest(ch.getFDVal(), ops);
    }

调用 pollWrapper的setInterest方法

void setInterest(int fd, int mask) { 
        synchronized (updateLock) { 
            // record the file descriptor and events
            int oldCapacity = updateDescriptors.length;
    
            // 扩容updateDescriptors数组
            if (updateCount == oldCapacity) { 
                int newCapacity = oldCapacity + INITIAL_PENDING_UPDATE_SIZE;
                int[] newDescriptors = new int[newCapacity];
                System.arraycopy(updateDescriptors, 0, newDescriptors, 0, oldCapacity);
                updateDescriptors = newDescriptors;
            }
    
            // 将更新过的文件描述符放到数组中
            updateDescriptors[updateCount++] = fd;
    
            // events are stored as bytes for efficiency reasons
            byte b = (byte)mask;
            assert (b == mask) && (b != KILLED);
            // 更新event
            setUpdateEvents(fd, b, false);
        }
    }

这里代码虽然看起来很长，其实就干了2件事，1是将channel对应文件描述符fd维护到updateDescriptors 数组中，表示这个fd的关注的事件发生了变更，  
2是调用 setUpdateEvents(fd, b, false)方法将fd对应的事件维护到数组或者是map中去，这个方法上面有介绍，这里不再赘述。  
好了到这里我们注册逻辑就ok了。

### 总结 ###

到这里`serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);` 这行代码底层实现原理我们就剖析完成了，主要是生成对应的selectionKey，然后将channel对应的fd 与 selectionKey维护到一个map中，同时还有一些其他数据结构的数据维护，最后就是设置感兴趣的事件这里也就是OP\_ACCEPT事件，将java nio事件转成epoll事件，然后维护fd与事件对应关系，将fd放到变更数据中。