Fork me on GitHub

NIO

字数统计: 2.9k字   |   阅读时长≈ 11分

同步,异步,阻塞,非阻塞

同步和阻塞：

完成一件事，需要调用a1,a2,a3方法，a1在执行的情况下，a2,a3不能执行，

异步和非阻塞：

完成一件事，需要调用a1,a2,a3方法，a1在执行的情况下，a2,a3也可以执行

同步阻塞：

完成一件事，需要调用a1,a2,a3方法，a1在执行的情况下，a2,a3不能执行，调用a1的线程不能动，必须等到a1执行完（调用线程就是a1的执行线程）

同步非阻塞：

完成一件事，需要干a1,a2,a3这些事，a1在执行的情况下，a2,a3不能执行，调用a1的线程是活动的，就是a1在执行时，可以调用a2或者a3，但是为了同步 他不能干其他事，只能轮询看a1有没有执行完（调用线程与a1的执行线程不一样）

异步

（个人认为）首先我认为异步没有阻塞和非阻塞

完成一件事，需要调用a1,a2,a3方法，a1在执行的情况下，a2,a3也可以执行 ，就是一个线程调用a1，a2,a3时不会立马执行，但是会交给其他线程执行（a1,a2,a3的执行线程都可以是调用线程，也可以不是），自己可以设置钩子，来让执行a1,a2,a3的线程进行回调

异步就是内部进行一下包装，a1,a2,a3的执行跟彼此无关的，不知道谁先执行，谁后执行，反正最后回调钩子函数

总结

同步，异步都是逻辑上的概念，实现方式自己定

阻塞和非阻塞就是具体的东西

NIO

NIO里面的FileChannel是同步的

NIO 叫做NEW IO ，提出了新的概念，引入多路选择器Selector，Channel和Bytebuffer

名词

Channel

一个IO流的通道

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
//具备一个IO操作能力，一旦closed，任何IO操作都会报异常
Channel
    
//具备IO读取的能力，一个线程使用可读的channel发起一个读操作，那么其他线程在想要发起读操作就只能阻塞直到第一个读操作完成
ReadableByteChannel 实现  Channel
    
//具备IO写的能力，同样多个线程发起IO写操作，得一个一个来
WritableByteChannel 实现  Channel

//一个可以读写字节的channel
ByteChannel 实现 ReadableByteChannel，WritableByteChannel
    
//能够使ByteChannel保持当前position并且允许修改当前position得能力    
//通常一个文件类型得实体，    
SeekableByteChannel 实现 ByteChannel 

//可以在一个Buffer数组中读取字节
ScatteringByteChannel 实现ReadableByteChannel    
// 可以在一个Buffer数组中把字节写出去   
GatheringByteChannel 实现WritableByteChannel
    
//有 异步关闭和 中断的能力的channel    
InterruptibleChannel 实现channel    

AbstractInterruptibleChannel 实现Channel，InterruptibleChannel
    
//该channel 表示为网络的一个socket    
NetworkChannel 实现 Channel    
     bind(SocketAddress local);本机地址绑定到 该channel的socket
     getLocalAddress()；返回此socket绑定的本机地址
     setOption(SocketOption<T> name, T value)  设置Socket选项
     getOption(SocketOption<T> name)，通过指定的SocketOption来获取值
     supportedOptions();返沪所支持的socket选项
    
//可以通过selector进行多路复用的channel    
SelectableChannel 继承AbstractInterruptibleChannel，实现channel    
    provider();返回一个创建按该channel的provider
    validOps();返回该channel所支持的的操作集
    isRegistered();该channel是否被注册到任意的一个seletor，初始的该channel是没有被注册的
    keyFor(Selector sel)；返回channel在给定selector上的注册信息 SelectionKey
    register(Selector sel, int ops, Object att);在给定的选择器上注册该channel，如果几经注册过，将返回注册的key，key的感兴趣的操作事件将会被指定成传进去的ops
    configureBlocking(boolean block)；调整该channel是否是阻塞的
    isBlocking();判断这个channel是否阻塞
    blockingLock();返回一个锁对象 ，一般用在同步操作
        
    
        
//实现基本模板 是多路复用的一个基类        
AbstractSelectableChannel 继承SelectableChannel   
    

    
//一个面向流的监听socket，它具有多路复用的能力
ServerSocketChannel 继承AbstractSelectableChannel，实现NetworkChannel
    open() 使用工厂方法创建一个本类实例
    validOps() 返回这个channel所支持的operations
    bind(SocketAddress local, int backlog)；绑定，并设置最大的监听数
    socket();返回该channel的socket
    accept() 使用该channel的socket接待一个连接
    
    
//可选择的渠道面向数据流连接的套接字    
SocketChannel 继承AbstractSelectableChannel 实现了ByteChannel，ScatteringByteChannel，GatheringByteChannel，NetworkChannel
     open() 使用工厂方法创建一个本类实例
     open(SocketAddress remote);调用了open()创建一个的该类实例，并且连接远程机器，返回该实例
     isConnected();
	 socket();返回该channel的socket
     validOps() 返回这个channel所支持的operations
     shutdownInput() 关闭输入流
     shutdownOutput() 关闭输出流
     isConnectionPending(); 连接操作还在进行中，返回true
     connect(SocketAddress remote)；连接远程机器
     finishConnect()；如果连接完成 ，返回true，没有就返回false
     getRemoteAddress()；获取远程地址
     getLocalAddress() ；获取本机地址   
      
     一堆read，write方法

Buffer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
Buffer.class

原始类型 int char 等等
特定原始类型的数据的容器。
buffer是特定原始类型的一个线性，有限 元素序列 
buffer的基本属性
    capacity ：容量，包含多少个元素，不会为负，也不会变化大小
    limit： 临界值，是不应该被读或者写的第一个元素的索引，不会超过capacity
    position：起始位置 ，下一个 将被读或者写的元素的索引，大小不会超过limit（相当于是一个读写指针）
    
    0，1，2，3，4，5
                capacity为6
    4，5不能读写，limit=4 
    刚开始读      position=0
    
    其实数组就能满足它的buffer的所有特点
    
    
 
    mark <= position <= limit <= capacity 
    api:
		position();返回position 
		position(int newPosition)；设置position
    	limit()；返回limit
        limit(int newLimit)；设置  limit
        mark()；把mark =position，记录当前读或者写一个位置，用mark记录
        reset();把position设置成mark位置，如果mark没有标记过，那么会抛出异常 
    	clear()；limit，mark，poition，都重新设置成初始状态，相当于清空
        flip() ；limit设置成当前position位置，position设置0，mark设置成-1，大概的作用就是要把一个buffer用IO流写出去时，先调用一下flip(),告诉它只能把limit之前的字节写出去
        rewind()；position设置0，mark设置成-1，大该作用是在用IO流写出去一个buf之后，需要把内容copy到一个数组里面，此时需要再copy(get(array)操作）之前先调用rewind()；
        remaining();返回可读字节数
        hasRemaining() ；是否还有可读的字节
        isReadOnly();是不是只读的    
        hasArray();这个array不是空的并且不是只读的，就返回true
		array();  //返回buf里面的数组，如果是空的或者是只读的，会抛出异常
		arrayOffset();//返回buf里面的数组的offset
		isDirect();//是不是直接内存buffer                                              
		slice();//返回当前一个 可读写区域的一个子buf，使用的内存都是原来的内存
		duplicate();//复制这个buf，但是使用的内存都一样
                                                                                       
ByteBuffer.class  
    两种ByteBuffer
    Direct vs non-direct buffers :直接内存和非直接内存的比较
       non-direct buffers 
             1数据从硬件到  C或者C++写的内核 这里需要copy 到内存
             2内核到JVM虚拟机           这里需要copy 一份内存   
             3JVM虚拟机 到java进程堆内存 这里需要copy 一份内存    
       Direct
             1数据从硬件到  C或者C++写的内核 这里需要copy 到内存
        	 2内核到JVM虚拟机           这里需要copy 一份内存
			 直接内存在垃圾回收堆之外，意思就是GC不会管理该内存，所以建议Direct的ByteBuffer将主要分配给受底层系统本机I/O操作影响的大型、长寿命缓冲区。一般来说，只有当直接缓冲区在程序性能上产生可测量的增益时，才最好分配直接缓冲区。
		
       api：
     	allocateDirect(int capacity)；分配直接内存buffer	
        allocate(int capacity)分配一个非直接内存buffer	
		wrap(byte[] array,int offset, int length)；把一个数组转成非直接内存的buffer	
        wrap(byte[] array)把一个数组转成非直接内存的buffer
        
        //Singleton get/put methods
        get(); 获取一个字节      获取数组下标为position的位置的字节 然后position++
		put(byte b); 放进去一个  把b放到数组下标为position的位置  然后position++
        //下面api自己都可以猜出来
		get(int index);
		put(int index, byte b);
		//Bulk get operations 
		get(byte[] dst)
		get(byte[] dst, int offset, int length) 
        put(ByteBuffer src)
        put(byte[] src, int offset, int length)
        put(byte[] src)

selector

一个多路复用器，一个具备多路复用能力的Channel在该selector上的注册信息就是一个SelectionKey对象，selector具有三组 selection keys

key 集合 在该selector注册channel都会被拿出来，keys()可以获取

selected-key集合，key的子集，key集合的任意一个key的channel被检测到有 operations（key感兴趣的ops，就是在注册时需要指定的ops）确认信息，就会被放到selected-key集合，selectedKeys() 可以获取，通过获取该集合的迭代器 调用remove方法可以从selected-key集合直接移除当前遍历到的key

cancelled-key集合，key的子集，key集合的任意一个key被cancelled或者key的channel被close了，但是key的channel还没有被注销调，都被被放到selected-key集合，该集合不能直接被访问，这里面的key将不会参与下次 selection operations，并且移除keys集合对应再cancelled-key集合的key

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

open()；工厂方法，创建一个该类的实例，并打开selector
close()
isOpen();
provider();返回一个提供selector的一个工厂
keys(); 返回所有注册完成和等待被移除的key
selectedKeys(); 等待被操作 的key
wakeup();可以使选择操作立即返回。如果当前没有选择操作再执行，那么下一次选择操作会立即返回    
selectNow()；遍历出每一个有IO操作的事情的key，这个方法不阻塞，如果没有一个key有IO操作，那么返回0，之前任何的wakeup动作将会被消除不在生效，代操作的key放到了publicSelectedKeys里面    
    
select()；跟 selectNow()一样，只是它会阻塞，直到至少有一个channel有IO操作被选上，或者selector#wakeup方法被调用，或者调用线程被中断，才会结束阻塞  
    
select(long timeout)  ；再 select()基础上加了一个超时返回    
 
selectNow(Consumer<SelectionKey> action) ；写一个对SelectionKey的逻辑操作的动作，再当有IO操作时，会回调这个动作，该方法会立即返回，之前任何的wakeup动作将会被消除不在生效，publicSelectedKeys会被清空
    
select(Consumer<SelectionKey> action)；跟selectNow(Consumer<SelectionKey> action)方法一样，只不过他是阻塞的，只有当至少有一个channel有IO操作时,或者selector#wakeup方法被调用，或者调用线程被中断,才会停止阻塞
    
select(Consumer<SelectionKey> action, long timeout)；跟select(Consumer<SelectionKey> action)方法一样， 加了一个超时返回

SelectionKey

是一个 SelectableChannel注册再Selector上的一个令牌，标识，叫做selection key

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
channel(); 返回当前selection key的Channel
selector();返回当前selection key所在的selector
isValid();当前这个key是否有效
cancel(); 再selector上注销这个key
interestOps();返回 当前key关注的operations
interestOps(int ops)；重新设置 当前key关注的operations
interestOpsOr(int ops);当前key关注的operations与指定的 operations按位或 ，取并集  
interestOpsAnd(int ops)当前key关注的operations与指定的 operations按位与    取交集
readyOps();如果当前key的操作状态
    /*
    看这段代码就知道readyOps和interestOps的区别了
    判断key是不是可读的
     public final boolean isReadable() {
        return (readyOps() & OP_READ) != 0;
    }
    */
attach(Object ob)；这个方法不要想的太多，就是给key附加一个资源，方便调用资源或者识别这个key
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发
开源爱好者、Linux

联系QQ:2960571342

很惭愧

只做了一点微小的工作
谢谢大家