NIO中Buffer的重要属性关系解析

发表于

Buffer 是java NIO中三个核心概念之一 缓存, 在java的实现体系中Buffer作为顶级抽象类存在

简单说,Buffer在做什么?

我们知道,在java IO中体系中, 因为InputStream和OutputStream是抽象类,而java又不可以多重继承,于是任何一个流要么只读,要么只写.而无法完成同时读写的工作

于是: Buffer来了

NIO中,对数据的读写,都是在Buffer中完成的,也就是说,同一个buffer我们可以先读后写, 它底层维护着一个数组,这个数组被三个重要的属性控制,有机的工作结合,使buffer可读可写;

此外,Buffer是线程不安全的,并发访问需要同步

三个重要属性:

  • capacity: 容量
    • Buffer中元素的个数
    • 永远不能为负数
    • 永远不会变化
  • limit: 限制
    • 实际上它是Buffer所维护的那个数组中的一个下标
    • limit是第一个不能被读,或者第一个不能被写的元素的index
    • limit永远不会是负数
    • 永远不会超过capacity
  • Position: 定位
    • 指数组中下一个将要被读或者将要被写的元素的索引

图解,Buffer是如何维护的数组

一开始: 我们初始化它的大小为6 初始状态,Capacity和Limit都在最后一个不能被读或者不能被写的位置上

接着我们读入两个数据.position跳转到下一个将被读的index

接下来,准备写把buffer中的数据写出去两个, 于是我们需要反转数值

1
buffer.flip();

反转的逻辑:

1
2
limit=position;
position=0;

于是从0写 ,写到哪个位置? 写到limi前

写完毕后:如下图:

现在可以看到,pisition == limit

如果再想读入新的数据,同样需要反转数据flip()

但是此时,limit仍然是刚刚position的所在的最后的位置

Buffer架构体系:

模拟Buffer实现一个相同的继承体系,进一步了解成员变量在他们之间是怎么维护的

首先,和Buufer等级一样的顶级父类

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
public abstract class ParentSupper {
    private int position;
    private int capacity;

    ParentSupper(int position,int capacity){
        this.position=position;
        this.capacity=capacity;
        System.out.println("ParentSupper 的构造方法执行了... ");
    }

    final int nextPutIndex(){
        if (position>=capacity){
             throw new RuntimeException("索引异常");
        }
        return position++;
    }
 int i=0;

    final int nextGetIndex(){
        if (i >=position){
           throw new RuntimeException("索引异常");
        }
        return i++;
    }
}

接着是它的实现类, 和IntBuffer 等级一样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public abstract class Parent extends ParentSupper {
    // 抽象类中的成员变量,必须放在构造方法中
    final int[] arr1;
    int tag;

    // todo 执行父类的构造方法
    Parent(int a, int[] arr1) {
        // 调用父类的构造函数
        super(0,a);
        this.arr1 = arr1;
        this.tag = a;
    }

    // 构造器
    public static Parent allocate(int capacity) {
        return new Child(capacity);
    }

    // 抽象的方法
    public abstract int get();
    public abstract void put(int number);
}

作为抽象类的它,有自己的抽象方法, get put, 同时它里面维护着 核心数组, final不可变类型的, 抽象类中的变量不能单独存在,必须依附构造函数,于是我们添加它的构造函数

再就是它的实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  class Child extends Parent {
    public Child(int capacity) {
        super(capacity,new int[capacity]);
    }

    // todo 重写父类的构造方法
    @Override
    public int get() {
        return arr1[nextGetIndex()];
    }

    @Override
    public void put(int num) {
        arr1[nextPutIndex()]=num;
    }
}

注意,Child的类上并没有public 修饰,意味着他只是可以包内访问

下面测试:

1
2
3
4
5
6
7
8
9
10
11
12
public class text {
    public static void main(String[] args) {
        // 初始化
        Parent allocate = Parent.allocate(9);
         for (int i=0;i<9;i++){
             allocate.put(i);
         }
        for (int i=0;i<=8;i++){
            System.out.println( allocate.get());
        }
    }
}

运行流程是怎样的呢?

当我们使用
Parent.allocate(10);创建对象时,底层确实 new Child(int i), 同时把传递给Child, 而在Child()相应的构造函数中,接着调用的是spuer()方法,同时把10 传递给super也就是Parent,同时实例化了Parent的 数组, 在Supper的构造方法中,把0,和传递进来的10 传递给了SuperParent, 让他维护两个值

思考, 各个部分之间的作用

  • Buffer : 维护着当前数据的 position limit 和 capaciy值,这是数组的下标值,但是Buffer却没有数组
  • Buffer的直接实现类,如IntBuffer , 依然是抽象类, 它有数组作为缓存, 数组的维护它交给了它的父类Buffer, 针对数组的初始化,读写,他交给了自己的实现类

数组的维护工作是一样的,所以抽象成Buffer

  • HeapIntBuffer: 它继承了IntBuffer, 同时把它的父类的数组进行了实例化,并且重写了父类的get put方法

不同类型的数据,具体的读写是有区别的,所有抽象成不同的子类

在回去看,allocate(); 显然我们得到的是最外层的子类对象,这也就意味着他是最强的那个对象,它拥有父类的数据,并且这个数据的读写由它的爷爷替自己把关,这就是Buffer的设计模式

Buffer中常见的API

Buffer的所有子类全部定义了两套关于get() 和 put()的方法

  • Relative: 相对的读写, 相对的读写都是从当前的position的位置开始,每次的get/put都会是position的位置发生改变
  • Avsolute: 绝对的读写 , 用户指定索引, 从指定的索引里面get,或者直接往指定的索引里面put

clear()

将buffer置为初始状态的值,实际上就是让新读入buffer中的值,覆盖掉原来的值

1
2
position=0;
limit=capacity;

flip()

反转buffer

1
2
limit = position;
positon=0;

isReadOnly()

判断是否是只读的buffer

分片Buffer

1
2
3
4
5
//限制前后 准备切片
byteBuffer.position(2);
byteBuffer.limit(6);
// 切片
ByteBuffer slice = byteBuffer.slice();

新得到的buffer和原buffer共享内存空间

类型化的Buffer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ByteBuffer allocate = ByteBuffer.allocate(123);
    allocate.putInt(1);
    allocate.putChar('你');
    allocate.putDouble(123.123123);
    allocate.putShort((short) 2);
    allocate.putLong(3L);

    allocate.flip();

    System.out.println(allocate.getInt());
    System.out.println(allocate.getChar());
    System.out.println(allocate.getDouble());
    System.out.println(allocate.getShort());
    System.out.println(allocate.getLong());

类型化 的put和get 但是呢!!! 怎么存进去的 就得怎么取出来 , 否者会出现乱码

NIO拷贝文件

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
    // 获取输入流
    FileInputStream fileInputStream = new FileInputStream("123.txt");
    FileOutputStream fileOutputStream = new FileOutputStream("output123.txt");
    // 获取一个通道,关联上数据
    FileChannel channel = fileInputStream.getChannel();
    FileChannel outputStreamChannel = fileOutputStream.getChannel();
    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
    while (true) {
        // todo 每次读满一次缓存后, 重新初始化buffer
        byteBuffer.clear();

        // 将数据读入 缓存
        int read = channel.read(byteBuffer);
        System.out.println("read == "+read);
        if (read == -1) {
            break;
        }
        // 反转   limit=position   position=0
        byteBuffer.flip();

        // 通过channel 往输出流中写入缓存的数据
        outputStreamChannel.write(byteBuffer);
    }
    // 释放资源
    fileInputStream.close();
    fileInputStream.close();
    System.out.println("结束...");
}

每次循环一开始,都要重置buffer,否则第一轮读取结束之后, limit==position 从而channel里面新的数据读不进去,而 limit==position也不会引发异常,随后的flip()将buffer反转,position为0, 使得当前buffer中的数据被循环写到文件中,成为死循环