Channel
Channel管道是和IO操作对应的。 Channel 代表了针对io的一系列操作，无论这些io所属的类别（包括 磁盘io， 网络io 甚至是可以像io一样进行操作的程序组件，这里的io也是一种抽象）。
Channel管道要么是开启open状态，要么是关闭closed状态。Channel创建之后就进入开启状态。在调用close方法后计入关闭状态。isOpen（）方法可以获取Channel管道的开闭状态。
Channel的设计意图上希望是对多线程安全的，继承和实现这个接口的类都应该按照这样的标准来实现。
/**
* A nexus for I/O operations.
*
* <p> A channel represents an open connection to an entity such as a hardware
* device, a file, a network socket, or a program component that is capable of
* performing one or more distinct I/O operations, for example reading or
* writing.
*
* <p> A channel is either open or closed. A channel is open upon creation,
* and once closed it remains closed. Once a channel is closed, any attempt to
* invoke an I/O operation upon it will cause a {@link ClosedChannelException}
* to be thrown. Whether or not a channel is open may be tested by invoking
* its {@link #isOpen isOpen} method.
*
* <p> Channels are, in general, intended to be safe for multithreaded access
* as described in the specifications of the interfaces and classes that extend
* and implement this interface.
*
*
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
*/
public interface Channel extends Closeable
NetworkChannel
NetworkChannel 是针对网络io的管道。此接口通过bind（SocketAddress）方法来关联一个socket。setOption（SocketOption）和getOption（SocketOption）方法可以用来设置和查询socket操作。实现此接口的类应该表明它所能支持的操作类型。
需要特殊说明的是，bind(SocketAddress) 和 setOption（SocketOption）方法的返回值就是这个NetworkChannel，从而它可以提供这样的代码风格:netchannel.bind(a).bind(b).setOption(x).setOption(y)。有的地方把这种风格成为lambda风格。
/**
* A channel to a network socket.
*
* <p> A channel that implements this interface is a channel to a network
* socket. The {@link #bind(SocketAddress) bind} method is used to bind the
* socket to a local {@link SocketAddress address}, the {@link #getLocalAddress()
* getLocalAddress} method returns the address that the socket is bound to, and
* the {@link #setOption(SocketOption,Object) setOption} and {@link
* #getOption(SocketOption) getOption} methods are used to set and query socket
* options. An implementation of this interface should specify the socket options
* that it supports.
*
* <p> The {@link #bind bind} and {@link #setOption setOption} methods that do
* not otherwise have a value to return are specified to return the network
* channel upon which they are invoked. This allows method invocations to be
* chained. Implementations of this interface should specialize the return type
* so that method invocations on the implementation class can be chained.
*
* @since 1.7
*/
public interface NetworkChannel
extends Channel
SelectableChannel
SelectableChannel可用于多路复用的管道。 和selector一起使用的方式：先通过register(Selector, Object) 方法吧通道注册到复用器上，返回值SelectionKey就代表了这个注册关系。注册以后SelectableChannel处于注册状态，当它被反注册（取消注册）的时候，复用器Selector会吧Channel上分配的资源回收。而什么时候可以取消Channel的注册？当注册关系SelectionKey被Cancel方法取消的时候，Channel会被反注册。Channel自身无法反注册，他只能注册。
当Channel所在线程中断或者调用了Channel的close方法，Channel管道就会被关闭。Channel管道关闭的时候，所有相关的SelectionKey也会被取消Cancel。
使用isRegisted（）方法可以判断Channel是否已经注册。isBlocking（）方法表明了Channel管道是否是阻塞的。
可复用管道SelectableChannel当然也是对多线程安全的。
阻塞管道的io读写方法返回时， 数据是读写完毕的。非阻塞管道的io读写方法会立即返回，但不保证数据是读写完毕的，这个完毕是针对socket来讲的。
新创建的SelectableChannel默认是处于阻塞状态。SelectableChannel 和 Selector 联合使用的时候，非阻塞状态才能发挥最大的作用。一般在使用的使用需要把SelectableChannel设置为非阻塞然后和Selector注册。需要注意的是：一定要在注册之前设置为非阻塞状态，并且管道是无法再转换成阻塞状态，直到管道被反注册。
/**
* A channel that can be multiplexed via a {@link Selector}.
*
* <p> In order to be used with a selector, an instance of this class must
* first be <i>registered</i> via the {@link #register(Selector,int,Object)
* register} method. This method returns a new {@link SelectionKey} object
* that represents the channel's registration with the selector.
*
* <p> Once registered with a selector, a channel remains registered until it
* is <i>deregistered</i>. This involves deallocating whatever resources were
* allocated to the channel by the selector.
*
* <p> A channel cannot be deregistered directly; instead, the key representing
* its registration must be <i>cancelled</i>. Cancelling a key requests that
* the channel be deregistered during the selector's next selection operation.
* A key may be cancelled explicitly by invoking its {@link
* SelectionKey#cancel() cancel} method. All of a channel's keys are cancelled
* implicitly when the channel is closed, whether by invoking its {@link
* Channel#close close} method or by interrupting a thread blocked in an I/O
* operation upon the channel.
*
* <p> If the selector itself is closed then the channel will be deregistered,
* and the key representing its registration will be invalidated, without
* further delay.
*
* <p> A channel may be registered at most once with any particular selector.
*
* <p> Whether or not a channel is registered with one or more selectors may be
* determined by invoking the {@link #isRegistered isRegistered} method.
*
* <p> Selectable channels are safe for use by multiple concurrent
* threads. </p>
*
*
* <a name="bm"></a>
* <h2>Blocking mode</h2>
*
* A selectable channel is either in <i>blocking</i> mode or in
* <i>non-blocking</i> mode. In blocking mode, every I/O operation invoked
* upon the channel will block until it completes. In non-blocking mode an I/O
* operation will never block and may transfer fewer bytes than were requested
* or possibly no bytes at all. The blocking mode of a selectable channel may
* be determined by invoking its {@link #isBlocking isBlocking} method.
*
* <p> Newly-created selectable channels are always in blocking mode.
* Non-blocking mode is most useful in conjunction with selector-based
* multiplexing. A channel must be placed into non-blocking mode before being
* registered with a selector, and may not be returned to blocking mode until
* it has been deregistered.
*
*
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
*
* @see SelectionKey
* @see Selector
*/
public abstract class SelectableChannel
extends AbstractInterruptibleChannel
implements Channel
Selector
Selector 是 SelectableChannel的多路复用器。创建Selector有两种方式：1，使用Selector的open（）函数，该函数返回一个由默认的SelectorProvider创建的Selector复用器 ； 2，通过抽象类SelectorProvider的openSelector（）方法来定制个性化的Selector，也就是继承SelectorProvider。一个Selector默认是处于开启状态，close函数可以关闭复用器。
Selector和SelectableChannel之间的注册关系通过SelectionKey来表示。Selector主要维护三个注册集合（set of SelectionKeys）：1，key set ; 2, selected-key set; 3, cancelled-key set
1，key set ， 可以使用Selector的keys（）方法来获取这个集合。这个集合包含了注册到selector上的selectionKey
2，selected-key set ，使用selectedKeys（）来获取。如果一个key属于这个集合，那么说明这个key至少有一个关心的io操作可以进行。这个集合一定是key set 的一个子集。
3， cancelled-key set，这个集合外部无法直接访问。如果一个key已经被cancel但是对应的管道没有反注册，那么这个key就被放置在此集合中。从这里也可以看出来：key的cancel和管道的deregistered不是同步的。这个集合一定是key set 的一个子集。
在Selector刚创建的时候，这三个集合都是空的。那么这三个集合是在什么时候更新的？
1，当Channel通过register（Selector， int）方法注册到selector上的时候，对应的key被添加到key set 中。selector进行 选择操作（selection operations）的时候，会把处于cancelled状态的key移出这个集合。
2，当key被取消的时候，在下一次selector做选择操作的时候，会把key放入cancelled-key set 中， 同时，这个key也会从key set中移出。key被取消的时机前面也说过了，调用Channel的close或者Selectionkey的cancel
3， selected-key set 这个集合比较特殊。它并不是在 selector的选择操作中更新的。一个key一般并不会直接加入这个集合中，从这个集合当中移出一个key可以使用集合的remove方法。可以先简单的理解，在抽象的io操作（server接受连接、client连接成功，数据可读，数据课写）中有特定（interested）的操作的时候，selected-key set 会被更新。
Selector是多线程安全的。
/**
* A multiplexor of {@link SelectableChannel} objects.
*
* <p> A selector may be created by invoking the {@link #open open} method of
* this class, which will use the system's default {@link
* java.nio.channels.spi.SelectorProvider selector provider} to
* create a new selector. A selector may also be created by invoking the
* {@link java.nio.channels.spi.SelectorProvider#openSelector openSelector}
* method of a custom selector provider. A selector remains open until it is
* closed via its {@link #close close} method.
*
* <a name="ks"></a>
*
* <p> A selectable channel's registration with a selector is represented by a
* {@link SelectionKey} object. A selector maintains three sets of selection
* keys:
*
* <ul>
*
* <li><p> The <i>key set</i> contains the keys representing the current
* channel registrations of this selector. This set is returned by the
* {@link #keys() keys} method. </p></li>
*
* <li><p> The <i>selected-key set</i> is the set of keys such that each
* key's channel was detected to be ready for at least one of the operations
* identified in the key's interest set during a prior selection operation.
* This set is returned by the {@link #selectedKeys() selectedKeys} method.
* The selected-key set is always a subset of the key set. </p></li>
*
* <li><p> The <i>cancelled-key</i> set is the set of keys that have been
* cancelled but whose channels have not yet been deregistered. This set is
* not directly accessible. The cancelled-key set is always a subset of the
* key set. </p></li>
*
* </ul>
*
* <p> All three sets are empty in a newly-created selector.
*
* <p> A key is added to a selector's key set as a side effect of registering a
* channel via the channel's {@link SelectableChannel#register(Selector,int)
* register} method. Cancelled keys are removed from the key set during
* selection operations. The key set itself is not directly modifiable.
*
* <p> A key is added to its selector's cancelled-key set when it is cancelled,
* whether by closing its channel or by invoking its {@link SelectionKey#cancel
* cancel} method. Cancelling a key will cause its channel to be deregistered
* during the next selection operation, at which time the key will removed from
* all of the selector's key sets.
*
* <a name="sks"></a><p> Keys are added to the selected-key set by selection
* operations. A key may be removed directly from the selected-key set by
* invoking the set's {@link java.util.Set#remove(java.lang.Object) remove}
* method or by invoking the {@link java.util.Iterator#remove() remove} method
* of an {@link java.util.Iterator iterator} obtained from the
* set. Keys are never removed from the selected-key set in any other way;
* they are not, in particular, removed as a side effect of selection
* operations. Keys may not be added directly to the selected-key set. </p>
*
*
* <a name="selop"></a>
* <h2>Selection</h2>
*
* <p> During each selection operation, keys may be added to and removed from a
* selector's selected-key set and may be removed from its key and
* cancelled-key sets. Selection is performed by the {@link #select()}, {@link
* #select(long)}, and {@link #selectNow()} methods, and involves three steps:
* </p>
*
* <ol>
*
* <li><p> Each key in the cancelled-key set is removed from each key set of
* which it is a member, and its channel is deregistered. This step leaves
* the cancelled-key set empty. </p></li>
*
* <li><p> The underlying operating system is queried for an update as to the
* readiness of each remaining channel to perform any of the operations
* identified by its key's interest set as of the moment that the selection
* operation began. For a channel that is ready for at least one such
* operation, one of the following two actions is performed: </p>
*
* <ol>
*
* <li><p> If the channel's key is not already in the selected-key set then
* it is added to that set and its ready-operation set is modified to
* identify exactly those operations for which the channel is now reported
* to be ready. Any readiness information previously recorded in the ready
* set is discarded. </p></li>
*
* <li><p> Otherwise the channel's key is already in the selected-key set,
* so its ready-operation set is modified to identify any new operations
* for which the channel is reported to be ready. Any readiness
* information previously recorded in the ready set is preserved; in other
* words, the ready set returned by the underlying system is
* bitwise-disjoined into the key's current ready set. </p></li>
*
* </ol>
*
* If all of the keys in the key set at the start of this step have empty
* interest sets then neither the selected-key set nor any of the keys'
* ready-operation sets will be updated.
*
* <li><p> If any keys were added to the cancelled-key set while step (2) was
* in progress then they are processed as in step (1). </p></li>
*
* </ol>
*
* <p> Whether or not a selection operation blocks to wait for one or more
* channels to become ready, and if so for how long, is the only essential
* difference between the three selection methods. </p>
*
*
* <h2>Concurrency</h2>
*
* <p> Selectors are themselves safe for use by multiple concurrent threads;
* their key sets, however, are not.
*
* <p> The selection operations synchronize on the selector itself, on the key
* set, and on the selected-key set, in that order. They also synchronize on
* the cancelled-key set during steps (1) and (3) above.
*
* <p> Changes made to the interest sets of a selector's keys while a
* selection operation is in progress have no effect upon that operation; they
* will be seen by the next selection operation.
*
* <p> Keys may be cancelled and channels may be closed at any time. Hence the
* presence of a key in one or more of a selector's key sets does not imply
* that the key is valid or that its channel is open. Application code should
* be careful to synchronize and check these conditions as necessary if there
* is any possibility that another thread will cancel a key or close a channel.
*
* <p> A thread blocked in one of the {@link #select()} or {@link
* #select(long)} methods may be interrupted by some other thread in one of
* three ways:
*
* <ul>
*
* <li><p> By invoking the selector's {@link #wakeup wakeup} method,
* </p></li>
*
* <li><p> By invoking the selector's {@link #close close} method, or
* </p></li>
*
* <li><p> By invoking the blocked thread's {@link
* java.lang.Thread#interrupt() interrupt} method, in which case its
* interrupt status will be set and the selector's {@link #wakeup wakeup}
* method will be invoked. </p></li>
*
* </ul>
*
* <p> The {@link #close close} method synchronizes on the selector and all
* three key sets in the same order as in a selection operation.
*
* <a name="ksc"></a>
*
* <p> A selector's key and selected-key sets are not, in general, safe for use
* by multiple concurrent threads. If such a thread might modify one of these
* sets directly then access should be controlled by synchronizing on the set
* itself. The iterators returned by these sets' {@link
* java.util.Set#iterator() iterator} methods are <i>fail-fast:</i> If the set
* is modified after the iterator is created, in any way except by invoking the
* iterator's own {@link java.util.Iterator#remove() remove} method, then a
* {@link java.util.ConcurrentModificationException} will be thrown. </p>
*
*
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
*
* @see SelectableChannel
* @see SelectionKey
*/
public abstract class Selector implements Closeable
SelectionKey
这里捡要紧的说，废话就不多说了。SelectionKey，常见有两种操作，set（设置operations），test（检测操作）；设置operations有两种方式：调用Channel的register方法时候设置， 或者 ，调用SelectionKey的interestOps(int)方法。注意，设置的operations必须是对应的channel关心的操作（interest）。通过SelectableChannel的validOps（）函数可以查看channel关心的操作集合。设置validOps（）意外的operation会导致运行时异常。
SelectionKey的操作集合分为两类：1，interest set， 2，ready set。
interest set 中的操作是Selector在selection选择操作中将要检测的操作集合。
一个operation处于ready set 中，表明对应管道已经满足了进行这种操作的条件。SelectionKey的ready set 不能直接更新，它应该是在Selector的selection过程中更新。
/**
* A token representing the registration of a {@link SelectableChannel} with a
* {@link Selector}.
*
* <p> A selection key is created each time a channel is registered with a
* selector. A key remains valid until it is <i>cancelled</i> by invoking its
* {@link #cancel cancel} method, by closing its channel, or by closing its
* selector. Cancelling a key does not immediately remove it from its
* selector; it is instead added to the selector's <a
* href="Selector.html#ks"><i>cancelled-key set</i></a> for removal during the
* next selection operation. The validity of a key may be tested by invoking
* its {@link #isValid isValid} method.
*
* <a name="opsets"></a>
*
* <p> A selection key contains two <i>operation sets</i> represented as
* integer values. Each bit of an operation set denotes a category of
* selectable operations that are supported by the key's channel.
*
* <ul>
*
* <li><p> The <i>interest set</i> determines which operation categories will
* be tested for readiness the next time one of the selector's selection
* methods is invoked. The interest set is initialized with the value given
* when the key is created; it may later be changed via the {@link
* #interestOps(int)} method. </p></li>
*
* <li><p> The <i>ready set</i> identifies the operation categories for which
* the key's channel has been detected to be ready by the key's selector.
* The ready set is initialized to zero when the key is created; it may later
* be updated by the selector during a selection operation, but it cannot be
* updated directly. </p></li>
*
* </ul>
*
* <p> That a selection key's ready set indicates that its channel is ready for
* some operation category is a hint, but not a guarantee, that an operation in
* such a category may be performed by a thread without causing the thread to
* block. A ready set is most likely to be accurate immediately after the
* completion of a selection operation. It is likely to be made inaccurate by
* external events and by I/O operations that are invoked upon the
* corresponding channel.
*
* <p> This class defines all known operation-set bits, but precisely which
* bits are supported by a given channel depends upon the type of the channel.
* Each subclass of {@link SelectableChannel} defines an {@link
* SelectableChannel#validOps() validOps()} method which returns a set
* identifying just those operations that are supported by the channel. An
* attempt to set or test an operation-set bit that is not supported by a key's
* channel will result in an appropriate run-time exception.
*
* <p> It is often necessary to associate some application-specific data with a
* selection key, for example an object that represents the state of a
* higher-level protocol and handles readiness notifications in order to
* implement that protocol. Selection keys therefore support the
* <i>attachment</i> of a single arbitrary object to a key. An object can be
* attached via the {@link #attach attach} method and then later retrieved via
* the {@link #attachment() attachment} method.
*
* <p> Selection keys are safe for use by multiple concurrent threads. The
* operations of reading and writing the interest set will, in general, be
* synchronized with certain operations of the selector. Exactly how this
* synchronization is performed is implementation-dependent: In a naive
* implementation, reading or writing the interest set may block indefinitely
* if a selection operation is already in progress; in a high-performance
* implementation, reading or writing the interest set may block briefly, if at
* all. In any case, a selection operation will always use the interest-set
* value that was current at the moment that the operation began. </p>
*
*
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
*
* @see SelectableChannel
* @see Selector
*/
public abstract class SelectionKey
总结
高并发需要使用nio，它提供了单线程处理多io的能力。Java原生Nio中的主要概念是：channel，operation ，selectionKey，selector
channel可以看做是对io流的封装，它不仅仅是简单的封装而已。还需要对应一些缓冲设置等。
operation 抽象表示针对io流的一种操作，例如连接成功，流可写，流可读。
selector是io操作的执行者，主要是他的selection方法。
selectionKey表示channel和selector之间的关系。