NIO（一）——Buffer

NIO简介

- NIO即New IO，是用来代替标准IO的，提供了与标准IO完全不同传输方式。
- 核心：通道（Channel）和缓冲区（Buffer）和选择器（Selectors），Channel负责传输，Buffer负责存储

与标准IO的区别

- 标准IO是面向字节流的，NIO是面向缓冲区的
- 标准IO是阻塞IO，NIO是非阻塞IO

当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。

NIO具有选择器Selectors

选择器用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道

缓冲区Buffer
- - 在Java NIO中负责数据的存取。缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。
  - 根据数据类型的不同，提供了不同类型的缓冲区（boolean除外）：
1. ByteBuffer
2. ShortBuffer
3. IntBuffer
4. LongBuffer
5. FloatBuffer
6. DoubleBuffer
7. CharBuffer
上述缓冲区的管理方式几乎一致，通过allocate()获取缓冲区：

ByteBuffer buf = ByteBuffer.allocate(1024);

缓冲区存储数据的两个核心方法：

put():存数据到缓冲区
get():从缓冲区取数据

缓冲区中的核心属性：

capacity：容量，表示缓冲区中最大存储数据的容量，一旦声明不可改变
limit：界限，表示缓存区冲可以操作数据的大小。limit后的数据不能进行读写（读和写操作含义不同）
position：位置，表示缓冲区中正在操作的数据的位置
mark：标记，表示记录当前position的位置，可以通过reset()恢复到mark的位置
0<=mark<=position<=limit<=capacity

方法：
- flid()方法：在切换读写模式的时候必须调用flid()方法
1. buf.flip();
2. flip()方法：

                  public final Buffer flip() {
                            limit = position;
                            position = 0;
                                mark = -1;
                            return this;
                        }

rewind()方法：

可重复读数据，将position置0，limit不变

  public final Buffer rewind() {
        position = 0;
        mark = -1;
        return this;
    }

clear()与compact()方法：

一旦读完缓冲区中的数据，需要让缓冲区准备好再次被写入。可以通过clear（）或compact方法来完成。
如果调用的是clear（）方法，position将被置0，limit被设置为capacity的值。即缓冲区被清空。但缓冲区中的数据并未被清除。
如果缓冲区中有一些未读的数据，调用clean()方法，数据将“被遗忘”。
如果缓冲区中有一些未读的数据，且后续还需要这些数据，但此时想先写些数据，就使用compact()方法。compact()方法将所有未读的数据拷贝到Buffer起始处，然后将position设到最后一个未读元素后面，limit=capacity。

   public final Buffer clear() {
        position = 0;
        limit = capacity;
        mark = -1;
        return this;
    }

   public abstract ByteBuffer compact();

直接缓冲区与非直接缓冲区：

非直接缓冲区：通过allocate()方法分配缓冲区，将缓冲区建立在JVM内存中

 public static ByteBuffer allocate(int capacity) {
      	if (capacity < 0)
          	throw new IllegalArgumentException();
     	return new HeapByteBuffer(capacity, capacity);
    }

HeapByteBuffer(int cap, int lim) {   
  	super(-1, 0, lim, cap, new byte[cap], 0)；
    }

ByteBuffer(int mark, int pos, int lim, int cap, byte[] hb, int offset){
    			 super(mark, pos, lim, cap);
   			 this.hb = hb;
      			this.offset = offset;
    }

直接缓冲区：
通过allocateDirect()方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率

 public static ByteBuffer allocateDirect(int capacity) {
     		return new DirectByteBuffer(capacity);
  			 }

 DirectByteBuffer(int cap) {      
        super(-1, 0, cap, cap);
        boolean pa = VM.isDirectMemoryPageAligned();
          //调用直接内存方法进行分配
        int ps = Bits.pageSize();
        long size = Math.max(1L, (long)cap + (pa ? ps : 0));
        Bits.reserveMemory(size, cap);

        long base = 0;
        try {
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }

NIO（一）——Buffer

NIO（一）——Buffer

猜你喜欢