NIO源码阅读笔记（二） Channel

1. 关于Channel

Channel是一个对象，可以通过它读取和写入数据。可以把它看做IO中的流。但是它和流相比还有一些不同：

（1） Channel是双向的，既可以读又可以写，而流是单向的
（2） Channel可以进行异步的读写
（3） 对Channel的读写必须通过buffer对象
正如上面提到的，所有数据都通过Buffer对象处理，所以，您永远不会将字节直接写入到Channel中，相反，您是将数据写入到Buffer中；同样，您也不会从Channel中读取字节，而是将数据从Channel读入Buffer，再从Buffer获取这个字节。

在Java NIO中Channel主要有如下几种类型：

FileChannel：从文件读取数据的
DatagramChannel：读写UDP网络协议数据
SocketChannel：读写TCP网络协议数据
ServerSocketChannel：可以监听TCP连接

2. 关于Channel的几个重要方法：

• 2.1 定义在Channel接口中的 isOpen() 以及close()

public interface Channel extends Closeable {
    public boolean isOpen();
    public void close() throws IOException;
}

这两个方法是所有Channel都必须实现的方法，这里只做简单的了解。

• 2.2 open()
  关于open()方法，在不同的Channel中有不同的实现。在这里也不对open()方法坐具体的讨论。

• 2.3 关于Channel的register

Channel的注册定义在SelectableChannel类中：

	public abstract SelectionKey register(Selector sel, int ops, Object att)
        throws ClosedChannelException;
    public final SelectionKey register(Selector sel, int ops)
        throws ClosedChannelException
    {
        return register(sel, ops, null);
    }

具体实现在AbstractSelectableChannel类中：
需要传入三个参数：
sel 选择器
ops 设置的兴趣
att 生成密钥的附件;一般为null

兴趣定义在SelectionKey类中，有以下几个值：

    public static final int OP_READ = 1 << 0;

    public static final int OP_WRITE = 1 << 2;

    public static final int OP_CONNECT = 1 << 3;
    
    public static final int OP_ACCEPT = 1 << 4;

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;
        }
    }

首先判断Channel是否打开，未打开则抛出异常；其次判断Channel的兴趣设置是否正确，validOps()在不同的Channel中有不同的实现；最后判断是否是阻塞模式，如果为阻塞模式，抛出异常；
以上三个判断皆不成立后，进入findKey方法：

private SelectionKey[] keys = null;

private SelectionKey findKey(Selector sel) {
        synchronized (keyLock) {
            if (keys == null)
                return null;
            for (int i = 0; i < keys.length; i++)
                if ((keys[i] != null) && (keys[i].selector() == sel))
                    return keys[i];
            return null;
        }
    }

如果是第一次注册，keys==null，直接返回null;否则遍历数组，如果找到SelectionKey 中持有当前Selector，则直接返回SelectionKey，否则返回null。
接下来判断k是否为null：
如果k不为null，说明已经注册过了：调用interestOps方法：

public SelectionKey interestOps(int var1) {
        this.ensureValid();
        return this.nioInterestOps(var1);
    }

首先通过.ensureValid()判断当前SelectionKey 是否是有效的：

private void ensureValid() {
        if (!this.isValid()) {
            throw new CancelledKeyException();
        }
    }

调用isValid()方法，如果无效则抛出异常。
如果是有效的则调用nioInterestOps方法：

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

和register方法中一样，判断兴趣值是否正确，如果不正确则抛出异常；如果正确则调用translateAndSetInterestOps方法，translateAndSetInterestOps在不同的Channel中有不同的个实现方式，以SocketChannel为例，该方法的实现在SocketChannelImpl类中：

public void translateAndSetInterestOps(int var1, SelectionKeyImpl var2) {
        int var3 = 0;
        if ((var1 & 1) != 0) {
            var3 |= Net.POLLIN;
        }

        if ((var1 & 4) != 0) {
            var3 |= Net.POLLOUT;
        }

        if ((var1 & 8) != 0) {
            var3 |= Net.POLLCONN;
        }

        var2.selector.putEventOps(var2, var3);
    }

用参数var3来保存各兴趣值，接下来调用selector的putEventOps方法，该方法的实现在WindowsSelectorImpl类中：

public void putEventOps(SelectionKeyImpl var1, int var2) {
        Object var3 = this.closeLock;
        synchronized(this.closeLock) {
            if (this.pollWrapper == null) {
                throw new ClosedSelectorException();
            } else {
                int var4 = var1.getIndex();
                if (var4 == -1) {
                    throw new CancelledKeyException();
                } else {
                    this.pollWrapper.putEventOps(var4, var2);
                }
            }
        }
    }

首先检测轮询数组是否为null，如果为null则抛出异常；否则用var4保存SelectionKeyImpl中保存的数组下标，对下标进行合法性检查，最后对轮询数组设置事件响应，pollWrapper.putEventOps最后是一个native方法。

设置完毕后，回到nioInterestOps方法，保存兴趣值并返回SelectionKey。紧接着回到register方法调用attach方法：

 	private static final AtomicReferenceFieldUpdater<SelectionKey,Object>
        attachmentUpdater = AtomicReferenceFieldUpdater.newUpdater(
            SelectionKey.class, Object.class, "attachment"
        );
        
	 public final Object attach(Object ob) {
        return attachmentUpdater.getAndSet(this, ob);
    }

下面看看k为null的情况：
首先判断Channel是否关闭，若关闭则抛出异常，否则调用AbstractSelector类中的register方法，该方法在SelectorImpl类中实现：

	protected final SelectionKey register(AbstractSelectableChannel var1, int var2, Object var3) {
        if (!(var1 instanceof SelChImpl)) {
            throw new IllegalSelectorException();
        } else {
            SelectionKeyImpl var4 = new SelectionKeyImpl((SelChImpl)var1, this);
            var4.attach(var3);
            Set var5 = this.publicKeys;
            synchronized(this.publicKeys) {
                this.implRegister(var4);
            }

            var4.interestOps(var2);
            return var4;
        }
    }

首先是类类型检测，如果类类型检测正确则创建SelectionKeyImpl对象，进入SelectionKeyImpl的构造方法：

 SelectionKeyImpl(SelChImpl var1, SelectorImpl var2) {
        this.channel = var1;
        this.selector = var2;
    }

这个构造方法比较容易，对channel和selector对象进行赋值。然后调用attach方法更新附件，接着调用implRegister抽象方法，该方法在WindowsSelectorImpl类中实现：

 protected void implRegister(SelectionKeyImpl var1) {
        Object var2 = this.closeLock;
        synchronized(this.closeLock) {
            if (this.pollWrapper == null) {
                throw new ClosedSelectorException();
            } else {
                this.growIfNeeded();
                this.channelArray[this.totalChannels] = var1;
                var1.setIndex(this.totalChannels);
                this.fdMap.put(var1);
                this.keys.add(var1);
                this.pollWrapper.addEntry(this.totalChannels, var1);
                ++this.totalChannels;
            }
        }
    }

首先判断是否需要扩容growIfNeeded()：

 	private static final int MAX_SELECTABLE_FDS = 1024;
	 private SelectionKeyImpl[] channelArray = new SelectionKeyImpl[8];
	 private int totalChannels = 1;
  
	private void growIfNeeded() {
        if (this.channelArray.length == this.totalChannels) {
            int var1 = this.totalChannels * 2;
            SelectionKeyImpl[] var2 = new SelectionKeyImpl[var1];
            System.arraycopy(this.channelArray, 1, var2, 1, this.totalChannels - 1);
            this.channelArray = var2;
            this.pollWrapper.grow(var1);
        }

        if (this.totalChannels % 1024 == 0) {
            this.pollWrapper.addWakeupSocket(this.wakeupSourceFd, this.totalChannels);
            ++this.totalChannels;
            ++this.threadsCount;
        }
        
    }

可以看到这个channelArray一开始固定初始化大小是8，而totalChannels 一开始就是1，最大为1024，这是为了方便后面的操作，channelArray 中下标为0的元素没用使用，直接从下标为1开始。
如果totalChannels 等于数组长度，则进行扩容，然后对数组元素进行复制，最后对pollWrapper进行扩容：

 void grow(int var1) {
        PollArrayWrapper var2 = new PollArrayWrapper(var1);

        for(int var3 = 0; var3 < this.size; ++var3) {
            this.replaceEntry(this, var3, var2, var3);
        }

        this.pollArray.free();
        this.pollArray = var2.pollArray;
        this.size = var2.size;
        this.pollArrayAddress = this.pollArray.address();
    }

逻辑很简单，就是把原来的socket句柄fdVal和事件响应events复制到新的PollArrayWrapper对象中，且位置不变，最后对各个相关成员重新赋值。

如果totalChannels 是1024的整数倍，则调用addWakeupSocket方法，这个方法在WindowsSelectorImpl的构造方法中也被调用过：

	 WindowsSelectorImpl(SelectorProvider var1) throws IOException {
        super(var1);
        this.wakeupSourceFd = ((SelChImpl)this.wakeupPipe.source()).getFDVal();
        SinkChannelImpl var2 = (SinkChannelImpl)this.wakeupPipe.sink();
        var2.sc.socket().setTcpNoDelay(true);
        this.wakeupSinkFd = var2.getFDVal();
        this.pollWrapper.addWakeupSocket(this.wakeupSourceFd, 0);
    }
	void addWakeupSocket(int var1, int var2) {
        this.putDescriptor(var2, var1);
        this.putEventOps(var2, Net.POLLIN);
    }

显而易见传入的var1是在selector一开始打开的时候生成的sourcechannel的描述符fdval，响应时间Net.POLLIN对应的是OP_READ。

扩容方法结束后，先在SelectionKeyImpl数组channelArray中加入当SelectionKeyImpl，并将其所处下标存入当前SelectionKeyImpl对象中。接着继续将SelectionKeyImpl对象存入到fdMap中，fdMap保存的时Channel的描述符和SelectionKeyImpl的映射关系：

	private static final class MapEntry {
        SelectionKeyImpl ski;
        long updateCount = 0L;
        long clearedCount = 0L;

        MapEntry(SelectionKeyImpl var1) {
            this.ski = var1;
        }
    }
	private static final class FdMap extends HashMap<Integer, WindowsSelectorImpl.MapEntry> {
        static final long serialVersionUID = 0L;

        private FdMap() {
        }

        private WindowsSelectorImpl.MapEntry get(int var1) {
            return (WindowsSelectorImpl.MapEntry)this.get(new Integer(var1));
        }

        private WindowsSelectorImpl.MapEntry put(SelectionKeyImpl var1) {
            return (WindowsSelectorImpl.MapEntry)this.put(new Integer(var1.channel.getFDVal()), new WindowsSelectorImpl.MapEntry(var1));
        }

        private WindowsSelectorImpl.MapEntry remove(SelectionKeyImpl var1) {
            Integer var2 = new Integer(var1.channel.getFDVal());
            WindowsSelectorImpl.MapEntry var3 = (WindowsSelectorImpl.MapEntry)this.get(var2);
            return var3 != null && var3.ski.channel == var1.channel ? (WindowsSelectorImpl.MapEntry)this.remove(var2) : null;
        }
    }

	private WindowsSelectorImpl.MapEntry put(SelectionKeyImpl var1) {
            return (WindowsSelectorImpl.MapEntry)this.put(new Integer(var1.channel.getFDVal()), new WindowsSelectorImpl.MapEntry(var1));
        }

接下来调用keys的add方法添加当前SelectionKeyImpl对象，keys是其父类SelectorImpl的对象：

protected HashSet<SelectionKey> keys = new HashSet();

接着调用pollWrapper的addEntry方法：

	void addEntry(int var1, SelectionKeyImpl var2) {
        this.putDescriptor(var1, var2.channel.getFDVal());
    }

该方法仅进行了添加channel的描述符的操作，并未设置事件响应 。
最后对totalChannels进行自增，implRegister方法结束。

回到SelectorImpl类中的register，在implRegister方法结束后，调用interestOps设置事件响应，返回当前SelectionKey对象对AbstractSelectableChannel中的register方法中的k进行赋值，调用addKey方法，传入k：

private void addKey(SelectionKey k) {
        assert Thread.holdsLock(keyLock);
        int i = 0;
        if ((keys != null) && (keyCount < keys.length)) {
            // Find empty element of key array
            for (i = 0; i < keys.length; i++)
                if (keys[i] == null)
                    break;
        } else if (keys == null) {
            keys =  new SelectionKey[3];
        } else {
            // Grow key array
            int n = keys.length * 2;
            SelectionKey[] ks =  new SelectionKey[n];
            for (i = 0; i < keys.length; i++)
                ks[i] = keys[i];
            keys = ks;
            i = keyCount;
        }
        keys[i] = k;
        keyCount++;
    }

代码的逻辑比较简单，就不细说了，channe的注册到此结束。

• 2.4 configureBlocking(boolean block)
  configureBlocking方法是在AbstractSelectableChannel类中实现的。

这个方法是对阻塞或者非阻塞模式的设置，因为NIO既支持阻塞模式也支持非阻塞模式。NIO的非阻塞模式在网络编程中处理大量的网络通信是优于BIO的。

 public final SelectableChannel configureBlocking(boolean block)
        throws IOException
    {
        synchronized (regLock) {
            if (!isOpen())
                throw new ClosedChannelException();
            if (blocking == block)
                return this;
            if (block && haveValidKeys())
                throw new IllegalBlockingModeException();
            implConfigureBlocking(block);
            blocking = block;
        }
        return this;
    }

第一个if用来判断当前Channel是否已将打开，如果未打开，则抛出异常；
第二个if用来判断设置的是否为阻塞模式(默认blocking = true)；
第三个if：第二个if判断不成立但是第三个if判断成立的前提条件是：
block为true，haveValidKeys()为true
则抛出异常；
那么说明之前已经设置了非阻塞模式；

如果均不成立，则设置阻塞模式。
implConfigureBlocking()在不同的Channel中有不同的实现方案。并且最后都是对底层的操作，这里只做简单的了解。

haveValidKeys()方法在AbstractSelectableChannel类中实现，代码如下：

private boolean haveValidKeys() {
        synchronized (keyLock) {
            if (keyCount == 0)
                return false;
            for (int i = 0; i < keys.length; i++) {
                if ((keys[i] != null) && keys[i].isValid())
                    return true;
            }
            return false;
        }
    }

代码的逻辑比较简单，就不做分析了。
如果说以上三个if的判断均不成立，调用implConfigureBlocking方法设置为阻塞模式，implConfigureBlocking方法在不同的channel中有不同的实现方式，并且最终的实现都是native方法，这里不进行深究。