这个人不断监控洗衣机和电饭锅的状态->如果发生了某事件->则去处理->处理完毕后继续监控->直到所有任务都完成->
->运用到服务器程序->
while(一直等待，直到有接收连接就绪事件，读就绪事件或者写就绪事件)//阻塞
{
if(有客户连接)
{
接收客户连接 //非阻塞
}
if(某Socket的输入流有可读数据)
{
从输入流读数据 //非阻塞
}
if(某Socket的输入流可以写数据)
{
向输出流写数据 //非阻塞
}
}
->采用轮询->某一种操作就绪->就执行该操作->否则就查看是否还有其他就绪的操作可以执行->线程不会因为某一个操作还没有就绪就进入阻塞状态->一直傻等操作就绪->
->为了使轮询操作顺利就行->接收客户的连接/从输入流读数据/向输出流写数据->以非阻塞方式运行->非阻塞->当线程执行这些方法->如果操作为就绪，则立即返回->而不会一直等到操作就绪->
->线程接收Client连接时，如果没有客户连接->立即返回
->线程从输入流读数据时，如果输入流没有数据就立即返回或者如果输入流还没有足够的数据，就读取现有数据->返回
->while条件的操作是以阻塞进行->如果未发生任何事件则进入阻塞状态->至少有一个事件发生时->执行循环体内操作->通常会包含在特定条件下退出循环的操作->
landon理解:1.Java的NIO机制其实是采用了事件机制(Reactor/Observer)->
2.Selector轮询channels
3.NIO机制围绕Selecor+Channel
注意:selector事件到来时(只是判断是否可读/可写)->具体的读写还是由阻塞和非阻塞决定->如阻塞模式下,如果输入流不足r字节则进入阻塞状态,而非阻塞模式下则奉行能读到多少就读到多少的原则->立即返回->
->同理写也是一样->selector只是通知可写->但是能写多少数据也是有阻塞和非阻塞决定->如阻塞模式->如果底层网络的输出缓冲区不能容纳r个字节则会进入阻塞状态->而非阻塞模式下->奉行能输出多少就输出多少的原则->立即返回
->而对于accept->阻塞模式->没有client连接时，线程会一直阻塞下去->而非阻塞时->没有客户端连接->方法立刻返回null->
(1.个人理解selector只是通知acceptable->即有连接请求加到了连接队列->但是具体接收连接是由accept决定->如果是阻塞模式的话，假如此时连接队列因为一些原因变空,则accept的时候就会阻塞->)
总结:为了使轮询操作顺利就行->必须采用非阻塞方式->
5.java.nio主要类
1.ServerSocketChannel->ServerSocket替代类->支持阻塞通信与非阻塞通信->
2.SocketChannel->Socket替代类->支持阻塞通信与非阻塞通信->
3.Selector->为ServerSocketChannel监控接收连接就绪事件->为SocketChannel监控连接就绪/读就绪/写就绪事件->
4.SelectionKey->表示ServerSocketChannel和SocketChannel向Selctor注册事件的句柄->当一个SelectionKey对象位于Selecor对象的selected-keys集合中->表述与这个SelectionKey对象相关的事件就发生了->
->ServerSocketChannel和SocketChannel都是SelectableChannel的子类->SelectableChannel及其子类都可委托Selector来监控它们可能发生的事件->委托过程->注册事件过程->
->SelectionKey key = serverSocketChannel.register(selector,SelectioinKey.OP_ACCEPT)->serverSocketChannel向Selector接收连接就绪事件->
6.缓冲区Buffer
数据输入和输出往往是比较耗时的操作. 缓冲区从两个方面提高 I/O 操作的效率:
1. 减少实际的物理读写次数;
2.缓存区在创建时被分配内存, 这块内存区域一直被重用, 这可以减少动态分配和回收内存区域的次数.
-> 旧I/O 类库(对应 java.nio包) 中的 BufferedInputStream, BufferedOutputStream, BufferedReader 和 BufferedWriter 在其实现中都运用了缓冲区. java.nio 包公开了 Buffer API, 使得Java 程序可以直接控制和运用缓冲区.
a.public abstract class Buffer
b.public abstract class ByteBuffer extends Buffer->
allocate->HeapByteBuffer
allocateDirect->DirectByteBuffer
c.public abstract class MappedByteBuffer extends ByteBuffer
d.DirectByteBuffer extends MappedByteBuffer implements DirectBuffer
3.缓冲区属性
1.容量(capacity): 表示该缓冲区可以保存多少数据．
2.极限(limit): 表示缓冲区的当前终点, 不能对缓冲区中超过极限的区域进行读写操作. 极限是可以修改的, 这有利于缓冲区的重用. 例如, 假定容量100 的缓冲区已经填满了数据, 接着程序在重用缓冲区时, 仅仅将 10 个新的数据写入缓冲区中从位置0 到10 的区域, 这时可以将极限设为 10, 这样就不能读取先前的数据了. 极限是一个非负整数, 不应该大于容量.
3.位置(position): 表示缓冲区中下一个读写单元的位置, 每次读写缓冲区的数据时, 都会改变该值, 为下一次读写数据作准备. 位置是一个非负整数, 不应该大于极限.
->容量 ≥ 极限 ≥ 位置 ≥ 0
注-landon:其实还有一个属性mark.->临时存放的位置下标.
->#mark:mark设为position #reset:position设置mark.
->正常:mark<= positon -> 如果position < mark,mark会被抛弃( #position:if (mark > position) mark = -1)
4.缓冲区方法:
1.clear(): 把极限设为容量, 再把位置设为 0;
position = 0;limit = capacity;mark = -1;
2.flip(): 把极限设为位置, 再把位置设为 0;
limit = position;position = 0;mark = -1;
3.rewind(): 不改变极限, 把位置设为 0.
position = 0;mark = -1;
注-landon:其他方法:
1.public final Bufferposition(int newPosition)
2.public final Bufferlimit(int newLimit)
3. public final intremaining()
->return limit - position
4.compact:
->从当前位置position 到极限limit 的内容复制到 0 到 limit-position 的区域->
->1.System.arraycopy(this.hb, ix(position()), this.hb, ix(0), remaining())
2. position(remaining())
3. limit(capacity())
5.Buffer 类是一个抽象类,->不能被实例化.->共有 8 个具体的缓冲区类,->其中最基本的缓冲区是 ByteBuffer, 它存放的数据单元是字节(byte[]). ByteBuffer 类并没有提供公开的构造方法, 但是提供了两个获得 ByteBuffer 实例的静态工厂方法->
1.allocate(int capacity): 返回一个 ByteBuffer 对象, 参数capacity 指定缓冲区的容量.
->HeapByteBuffer
2.directAllocate(int capacity):返回一个 ByteBuffer 对象, 参数capacity 指定缓冲区的容量.->该方法返回的缓冲区称为直接缓冲区, 它与当前操作系统能够更好地耦合,->因此能进一步提高 I/O 操作的速度. 但是直接分配缓冲区的系统开销很大, 因此只有在缓冲区较大并且长期存在, 或者需要经常重用时, 才使用这种缓冲区.
->DirectByteBuffer
3.除 boolean 类型以外, 每种基本类型都有对应的缓冲区类,->包括 CharBuffer(char[]), DoubleBuffer(double[]), FloatBuffer(float[]), IntBuffer(int[]), LongBuffer(long[])和 ShortBuffer(short[]).
4.MappedByteBuffer,->它是 ByteBuffer 的子类.->MappedByteBuffer 能够把缓冲区和文件的某个区域直接映射
->public abstract class MappedByteBuffer extends ByteBuffer
->A direct byte buffer whose content is a memory-mapped region of a file
5. 缓冲区类都提供了读写缓冲区的方法:
get(): 相对读. 从缓冲区的当前位置读取一个单元的数据, 读完后把位置加 1;
get(int index): 绝对读. 从参数 index 指定的位置读取一个单元的数据;
put(): 相对写. 向缓冲区的当前位置写入一个单元的数据, 写完后把位置加 1;
put(int index): 绝对写. 向参数 index 指定的位置写入一个单元的数据.
7.字符编码Charset
1.java.nio.Charset 类的每个实例代表特定的字符编码类型->
2.字节序列->解码->字符串
字符串->编码->字节序列
3.Charset 类提供了编码与解码的方法:
1.ByteBuffer encode(String str)->对参数 Str 指定的字符串进行编码, 把得到的字节序列存放在一个 ByteBuffer 对象中, 并将其返回;
2.ByteBuffer encode(CharBuffer cb)->对参数 cb 指定的字符缓冲区中的字符进行编码,把得到的字节序列存放在一个 ByteBuffer 对象中, 并将其返回;
3.CharBuffer decode(ByteBuffer bb)->把参数 bb 指定的 ByteBuffer 中的字节序列进行解码, 把得到的字符序列存放在一个 CharBuffer 对象中, 并将其返回
4.Charset 类的静态 forName(String encode) 方法返回一个 Charset 对象->它代表参数 encode 指定的编码类型->
5.Charset 类还有一个静态方法 defaultCharset(),->它返回代表本地平台的默认字符编码的 Charset 对象->
8.通道Channel
1.通道 Channel 用来连接缓冲区与数据源或数据汇(数据目的地)->数据源的数据经过管道到达缓冲区, 缓冲区的数据经过通道到达数据汇->
2.数据源->通道->内存(缓冲区)->通道->数据汇
3.Channel类层次结构:
1.public interfaceChannelextends Closeable
#isOpen() #close()
2.public interfaceReadableByteChannelextends Channel
#read(ByteBuffer dst)
3.public interfaceWritableByteChannelextends Channel
#write(ByteBuffer src)
4.public interfaceScatteringByteChannelextends ReadableByteChannel
#read(ByteBuffer[] dsts) #read(ByteBuffer[] dsts, int offset, int length)
5.public interfaceGatheringByteChannelextends WritableByteChannel
#write(ByteBuffer[] srcs) #write(ByteBuffer[] srcs, int offset, int length)
6.public interfaceByteChannelextends ReadableByteChannel, WritableByteChannel
7.public abstract classSelectableChannelextends AbstractInterruptibleChannel implements Channel
#configureBlocking(boolean block) # register(Selector sel, int ops, Object att)
8.public abstract classAbstractSelectableChannelextends SelectableChannel
9.public abstract classServerSocketChannelextends AbstractSelectableChannel implements NetworkChannel
10.public abstract classSocketChannelextends AbstractSelectableChannel
implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, NetworkChannel
11.public abstract classFileChannelextends AbstractInterruptibleChannel
implements SeekableByteChannel, GatheringByteChannel, ScatteringByteChannel
4.ByteBuffer
ByteBuffer-> WritableByteChannel ->数据汇
5.ScatteringByteChannel->分散地读取数据->单个读取操作能填充多个缓冲区
GatheringByteChannel ->集中地写入数据.->集中写入数据是指单个写操作能把多个缓冲区的数据写入数据汇
->分散读取和集中写数据能够进一步提高输入和输出操作的速度
6.FileChannel代表一个与文件相连的通道->FileInputStream, FileOutputStream 和 RandomAccessFile 类中提供了 getChannel() 方法->返回FileChannel->
7.SelectableChannel 也是一种通道->它不仅支持阻塞的 I/O 操作, 还支持非阻塞的 I/O 操作.
9.SelectableChannel
1.SelectableChannel 类是一种支持阻塞 I/O 和非阻塞 I/O 的通道->在非阻塞模式下->读写数据不会阻塞->并且SelectableChannel 可以向 Selector 注册读就绪和写就绪等事件.->Selector 负责监控这些事件, 等到事件发生时, 比如发生了读就绪事件, SelectableChannel 就可以执行读操作了
2.public abstract SelectableChannelconfigureBlocking(boolean block) throws IOException
->参数block 为false, 表示把 SelectableChannel 设为非阻塞模式->
->默认情况下-> SelectableChannel 采用阻塞模式
3.public abstract booleanisBlocking()
->返回true表示阻塞模式
4.public abstract SelectionKeyregister(Selector sel, int ops, Object att) throws ClosedChannelException
public final SelectionKey register(Selector sel, int ops) throws ClosedChannelException
->向selector注册事件
-> SelectionKey key = socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE)->SocketChannel向 Selector 注册读就绪和写就绪事件
->返回一个 SelectionKey 对象, SelectionKey 用来跟踪被注册的事件
->register() 方法还有一个Object 类型的参数 attachment,->它用于为 SelectionKey 关联一个附件, 当被注册事件发生后, 需要处理该事件时, 可以从 SelectionKey 中获得这个附件, 该附件可用来包含与处理这个事件相关的信息->
->如SelectionKey key = socketChannel.register(selector, SelectioinKey.OP_READ | SelectionKey.OP_WRITE, new EventHandler());
->等价于:SelectionKey key = socketChannel.register(selector, SelectioinKey.OP_READ | SelectionKey.OP_WRITE);
key.attach(new EventHandler());
10.ServerSocketChannel
1.从 SeletableChannel 中继承了 configureBlocking() 和 register()方法
2.ServerSocketChannel 是 ServerSocket 的替换类
3.public static ServerSocketChannelopen() throws IOException
->返回一个 ServerSocketChannel 对象, 这个对象没有与任何本地端口绑定, 并且处于阻塞模式->
->serverSocketChannel.socket().bind(port)->绑定到一个本地端口
4. public abstract SocketChannelaccept() throws IOException
->如果 ServerSocketChannel 处于非阻塞状态, 当没有客户连接时, 该方法立即返回 null
->如果ServerSocketChannel 处于阻塞状态, 当没有客户连接时, 它会一直阻塞下去, 直到有客户连接就绪, 或者出现了IOException.
->serverSocketChannel.configureBlocking(false)->修改为非阻塞模式运行
5. public final intvalidOps()
->return SelectionKey.OP_ACCEPT
6.public abstract ServerSocketsocket()
->返回关联的ServerSocket对象->每个 ServerSocketChannel 对象都与一个 ServerSocket 对象关联->
11.SocketChannel
1.可看作是 Socket 的替代类
2.不仅从 SelectableChannel 父类中继承了 configureBlocking() 和 register() 方法, 并且实现了 ByteChannel 接口
3.public static SocketChannelopen() throws IOException
public static SocketChannel open(SocketAddress remote)
->open(SocketAddress remote)会建立建立与远程服务器的连接->
->socketChannel.connect(remote)等价SocketChannel socketChannel = SocketChannel.open(remote)
->socketChannel.configureBlocking(false)->修改为非阻塞模式运行
4. public final intvalidOps()
->return (SelectionKey.OP_READ | SelectionKey.OP_WRITE| SelectionKey.OP_CONNECT)
5.public abstract Socketsocket()
->返回与这个SocketChannel 关联的 Socket 对象. 每个 SocketChannel 对象都与一个 Socket 对象关联
6.public abstract booleanisConnected()
->return true,if, and only if, this channel's network socket is{@link#isOpen open} and connected.
7.public abstract booleanisConnectionPending()
->判断是否正在进行远程连接. 当远程连接操作已经开始, 但是还没有完成时, 则返回true
->return true,if, and only if, a connection operation has been initiated on this channel but not yet completed by invokingthe{@link#finishConnect finishConnect} method(发起连接尚未调用调用finishConnect)
8.public abstract booleanconnect(SocketAddress remote) throws IOException
->使底层Socket 建立远程连接-> 当SocketChannel 处于非阻塞模式时, 如果立即连接成功, 该方法返回true, 如果不能立即连接成功, 该方法返回false->程序过会儿必须通过调用finishConnect() 方法来完成连接.
->当SocketChannel 处于阻塞模式, 如果立即连接成功, 该方法返回true, 如果不能立即连接成功, 将进入阻塞状态, 直到连接成功, 或者出现 I/O 异常
9.public abstract booleanfinishConnect() throws IOException
->试图完成连接远程服务器的操作->在非阻塞模式下, 建立连接从调用SocketChannel 的connect() 方法开始, 到调用 finishConnect() 方法结束. 如果finishConnect() 方法顺利完成连接, 或者在调用次方法之前连接已经建立, 则finishConnect() 方法立即返回true.
->如果连接操作还没有完成, 则立即返回false; 如果连接操作中遇到异常而失败, 则抛出响应的I/O 异常.
->阻塞模式下, 如果连接操作还没有完成, 则会进入阻塞状态, 直到连接完成或者出现I/O 异常
10.public intread(ByteBuffer dst) throws IOException
->从 Channel 中读入若干字节,->把他们存放到参数指定的 ByteBuffer 中. 假定执行read() 方法前, ByteBuffer 的位置为p, 剩余容量为r, r 等于dst.remaining() 方法的返回值. 假定read() 方法实际读入了 n 个字节, 那么 0 ≤ n ≤ r. read() 方法返回后, 参数 dst 引用的ByteBuffer 的位置变为 p+n, 极限保持不变->
->在阻塞模式下, read() 方法会争取读到 r 个字节, 如果输入流中不足 r 个字节, 就进入阻塞状态, 直到读入了 r 个字节, 或者读到了输入流末尾, 或者出现了 I/O 异常.
->非阻塞模式下, read() 方法奉行能读到多少数据就读多少数据的原则. read() 方法读取当前通道中的可读数据, 有可能不足 r 个, 或者为 0 个字节, read() 方法总是立即返回, 而不会等到读取了 r 个字节在返回
-> read() 方法返回的实际上读入的字节数, 有可能为 0. 如果返回 -1, 就表示读到了输入流的末尾
11.public intwrite(ByteBuffer src) throws IOException
->把参数 src 指定的 ByteBuffer 中的字节写到 Channel 中. 假定执行 write() 方法前, ByteBuffer 的位置为 p, 剩余容量为 r, r 等于 src.remaining() 方法的返回值. 假定 write() 方法实际上向通道中写了 n 个字节, 那么 0 ≤ n ≤ r. write() 方法返回后, 参数 src 引用的 ByteBuffer 的位置变为 p+n, 极限保持不变
->在阻塞模式下, write() 方法会争取输出 r 个字节, 如果底层网络的输出缓冲区不能容纳 r 个字节, 就进入阻塞状态, 直到输出了 r 个字节, 或者出现了 I/O 异常.
->非阻塞模式下, write() 方法奉行能输出多少数据就输出多少数据的原则, 有可能不足 r 个字节, 或者为 0 个字节, write() 方法总是立即返回, 而不会等到输出 r 个字节后再返回
->write() 方法返回实际上输出的字节数, 有可能为 0.
12.Selector
1.只要 ServerSocketChannel 及 SocketChannel 向 Selector 注册了特定的事件, Selector 就会监控这些事件是否发生-> SelectableChannel #register() 方法负责注册事件, 该方法返回一个SelectionKey 对象, 该对象是用于跟踪这些被注册事件的句柄
2. 一个Selector 对象中会包含 3 种类型的 SelectionKey 集合
1. public abstract Setkeys()
->The key set is not directly modifiable. A key is removed only after it has been cancelled and its channel has been deregistered. Any
attempt to modify the key set will cause an linkUnsupportedOperationException to be thrown
->当前所有向Selector 注册的 SelectionKey 的集合
-> publicKeys = Collections.unmodifiableSet(keys)
2.public abstract SetselectedKeys()
->Keys may be removed from, but not directly added to, the selected-key set. Any attempt to add an object to the key set will cause an UnsupportedOperationException} to be thrown.
->相关事件已经被Selector 捕获的SelectionKey 的集合.
->publicSelectedKeys = Util.ungrowableSet(selectedKeys)
3.cancelledKeys
->已经被取消的 SelectionKey 的集合
注-landon:
源码中selectedKeys和keys均是HashSet->但是对外提供的访问接口keys和selectedKeys返回的却是二者的public view->
publicSelectedKeys/publicKeys->返回的view均对set做了限制.
4.第二种和第三种集合都是第一种集合的子集. 对于一个新建的Selector 对象, 它的上述集合都为空
5.执行SelectableChannel # register() 方法时,->该方法新建一个 SelectionKey, 并把它加入到 Selector 的keys集合中
6.关闭了与SelectionKey 对象关联的 Channel 对象->或者调用了 SelectionKey 对象的cancel() 方法, 这个 SelectionKey 对象就会被加入到 cancelled-keys 集合中, 表示这个 SelectionKey 对象已经被取消, 在程序下一次执行 Selector 的 select() 方法时, 被取消的 SelectionKey 对象将从所有的集合(包括 all-keys 集合, selected-keys集合和cancelled-keys 集合)中删除->
7.执行 Selector 的 select() 方法时, 如果与 SelectionKey 相关的事件发生了, 这个SelectionKey 就被加入到 selected-keys 集合中. 程序直接调用 selected-keys 集合的 remove() 方法, 或者调用它的 Iterator 的 remove() 方法, 都可以从 selected-keys 集合中删除一个 SelectionKey 对象
注-landon:因为对外提供的是publicSelectedKeys->ungrowableSet->(只是不可add/addAll,否则会报出UnsupportedOperationException)
8.不允许直接通过集合接口的 remove() 方法删除 all-keys 集合中的 SelectionKey 对象
注-landon:因为对外提供的是publicKeys->unmodifiableSet->
9.public static Selectoropen() throws IOException
->Selector 的静态工厂方法, 创建一个 Selector 对象
10.public abstract boolean isOpen()
->true,if, and only if, this selector is open
->判断Selector 是否处于打开状态.->Selector 对象创建后就处于打开状态, 当调用那个了 Selector 对象的 close()
11. public abstract intselectNow() throws IOException
->返回相关事件已经发生的 SelectionKey 对象的数目. 该方法采用非阻塞的工作方式, 返回当前相关时间已经发生的 SelectionKey 对象的数目, 如果没有, 就立即返回 0
12.public abstract intselect() throws IOException
public abstract int select(long timeout)throws IOException
->该方法采用阻塞的工作方式, 返回相关事件已经发生的 SelectionKey 对象的数目, 如果一个也没有, 就进入阻塞状态, 直到出现以下情况之一, 才从 select() 方法中返回.
1.至少有一个 SelectionKey 的相关事件已经发生;
2.其他线程调用了 Selector 的 wakeup() 方法, 导致执行 select() 方法的线程立即从 select() 方法中返回.
3.当前执行 select() 方法的线程被其他线程中断.
4.超出了等待时间. 该时间由 select(long timeout) 方法的参数 timeout 设定, 单位为毫秒. 如果等待超时, 就会正常返回, 但不会抛出超时异常. 如果程序调用的是不带参数的 select() 方法, 那么永远不会超时, 这意味着执行 select) 方法的线程进入阻塞状态后, 永远不会因为超时而中断.
13.public abstract Selectorwakeup()
->唤醒执行 Selector 的 select() 方法(也同样设用于 select(long timeout) 方法) 的线程. 当线程A 执行 Selector 对象的 wakeup() 方法时, 如果线程B 正在执行同一个 Selector 对象的 select() 方法, 或者线程B 过一会儿会执行这个 Selector 对象的 select() 方法, 那么线程B 在执行 select() 方法时, 会立即从 select() 方法中返回, 而不会阻塞. 假如, 线程B 已经在 select() 方法中阻塞了, 也会立即被唤醒, 从select() 方法中返回.
->wakeup() 方法只能唤醒执行select() 方法的线程B 一次. 如果线程B 在执行 select() 方法时被唤醒后, 以后在执行 select() 方法, 则仍旧按照阻塞方式工作, 除非线程A 再次调用 Selector 对象的 wakeup() 方法
14.public abstract voidclose() throws IOException
->关闭 Selector. 如果有其他线程正执行这个Selector 的select() 方法并且处于阻塞状态, 那么这个线程会立即返回. close() 方法使得 Selector 占用的所有资源都被释放, 所有与 Selector 关联的 SelectionKey 都被取消
13.SelectionKey
1.ServerSocketChannel/SocketChannel #register() 方法向 Selector 注册事件时-> register() 方法会创建一个 SelectionKey 对象, 这个 SelectionKey 对象是用来跟踪注册事件的句柄->
2.在 SelectionKey对象的有效期间-> Selector 会一直监控与 SelectionKey 对象相关的事件, 如果事件发生, 就会把 SelectionKey 对象加入到 selected-keys 集合中.->在以下情况下, SelectionKey 对象会失效, 这意味着 Selector 再也不会监控与它相关的事件了:
1.程序调用 SelectionKey 的 cancel() 方法;
2.关闭与 SelectionKey 关联的 Channel;
3.与 SelectionKey 关联的 Selector 被关闭.
3.SelectionKey 中定义了 4 种事件->分别用 4 个 int 类型的常量来表示
1.SelectionKey.OP_READ
->读就绪事件, 表示通道中已经有了可读数据, 可以执行读操作了
->public static final int OP_READ = 1 << 0
2.SelectionKey.OP_WRITE
-> 写就绪事件, 表示已经可以向通道写数据了
->public static final int OP_WRITE = 1 << 2
3.SelectionKey.OP_CONNECT
->连接就绪事件, 表示客户与服务器的连接已经建立成功
->public static final int OP_CONNECT = 1 << 3
4.SelectionKey.OP_ACCEPT
->接收连接就绪事件, 表示服务器监听到了客户连接, 服务器可以接收这个连接了
->public static final int OP_ACCEPT = 1 << 4
5.各常量分别占据不同的二进制位, 因此可以通过二进制的或运算 "|", 来将它们进行任意组合->
->注:当然在判断某个事件发生的时候可以用&判断->
6.SelectionKey#interestOps()
->返回所有感兴趣的事件->
->如返回值为 SelectionKey.OP_WRITE | SelectionKey.OP_READ, 就表示这个 SelectionKey 对读就绪和写就绪事件感兴趣.->与之关联的 Selector 对象会负责监控这些事件
->SelectableChannel#register() 方法注册事件时, 可以在参数中指定 SelectionKey 感兴趣的事件
7.SelectionKey#interestOps(int ops)
->为 SelectionKey 对象增加一个感兴趣的事件
8.SelectionKey#readyOps()
->返回所有已经发生的事件
->如返回值为 SelectionKey.OP_WRITE | SelectionKey.OP_READ , 表示读就绪和写就绪事件发生了, 这意味着与之关联的 SocketChannel 对象可以进行读操作和写操作了
9.程序调用SelectableChannel#register时->
->建立SelectableChannel对象，Selector对象及register返回的SelectionKey对象之间的关联关系.
->SelectionKey->public abstract SelectableChannel channel()->返回关联的channel对象
->SelectionKey->public abstract Selector selector()->返回关联的selector对象
10.SelectionKey#public abstract booleanisValid()
->判断SelectionKey是否有效
->A key is valid upon creation and remains so until it is cancelled,its channel is closed, or its selector is closed.
11.SelectionKey# public abstract voidcancel()
->使SelectionKey失效
->Upon return the key will be invalid and will have been added to its selector's cancelled-key set
->The key will be removed from all of the selector's key sets during the next selection operation.
12.SelectionKey#public final booleanisReadable()
->判断与之关联的SocketChannel的读就绪是否已经发生
->return (readyOps() & OP_READ) != 0
13.SelectionKey#public final booleanisWritable()
->判断与之关联的SocketChannel的读就绪是否已经发生
->return (readyOps() & OP_WRITE) != 0
14.SelectionKey#public final booleanisConnectable()
->判断与之关联的SocketChannel的连接就绪是否已经发生
->return (readyOps() & OP_CONNECT) != 0
15.SelectionKey#public final booleanisAcceptable()
->判断与之关联的SocketChannel的接收连接就绪是否已经发生
->return (readyOps() & OP_ACCEPT) != 0
16.SelectionKey#public final Objectattach(Object ob)
->使SelectionKey关联一个附件
->只能关联一个Object类型附件
->多次调用该方法则最后一个附件关联
17.SelectionKey# public final Objectattachment()
->返回SelectionKey对象关联的附件
部分源码:
1635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
