NIO 之 ByteBuffer实现原理

最新推荐文章于 2023-07-18 14:47:51 发布
最新推荐文章于 2023-07-18 14:47:51 发布
阅读量3.5k 收藏 2
点赞数
分类专栏： 网络 文章标签： 缓冲区 NIO ByteBuffer 直接内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jijianshuai/article/details/77450695
版权
相关文章

IO、NIO、AIO 内部原理分析
NIO 之 Selector实现原理
NIO 之 Channel实现原理

前言

Java NIO 主要由下面3部分组成：

  • Buffer
  • Channel
  • Selector

在传统IO中，流是基于字节的方式进行读写的。
在NIO中，使用通道（Channel）基于缓冲区数据块的读写。

流是基于字节一个一个的读取和写入。
通道是基于块的方式进行读取和写入。

Buffer 类结构图

Buffer 的类结构图如下：
Buffer类结构图

从图中发现java中8中基本的类型，除了boolean外，其它的都有特定的Buffer子类。

Buffer类分析

Filed

每个缓冲区都有这4个属性，无论缓冲区是何种类型都有相同的方法来设置这些值

private int mark = -1;
private int position = 0;
private int limit;
private int capacity;
1. 标记（mark）

初始值-1，表示未标记。
标记一个位置，方便以后reset重新从该位置读取数据。

public final Buffer mark() {
    mark = position;
    return this;
}

public final Buffer reset() {
    int m = mark;
    if (m < 0)
        throw new InvalidMarkException();
    position = m;
    return this;
}
2. 位置（position）

缓冲区中读取或写入的下一个位置。这个位置从0开始，最大值等于缓冲区的大小

//获取缓冲区的位置
public final int position() {
    return position;
}
//设置缓冲区的位置
public final Buffer position(int newPosition) {
    if ((newPosition > limit) || (newPosition < 0))
        throw new IllegalArgumentException();
    position = newPosition;
    if (mark > position) mark = -1;
    return this;
}
3. 限度（limit）
//获取limit位置
public final int limit() {
    return limit;
}
//设置limit位置
public final Buffer limit(int newLimit) {
    if ((newLimit > capacity) || (newLimit < 0))
        throw new IllegalArgumentException();
    limit = newLimit;
    if (position > limit) position = limit;
    if (mark > limit) mark = -1;
    return this;
 }
4. 容量（capacity）

缓冲区可以保存元素的最大数量。该值在创建缓存区时指定，一旦创建完成后就不能修改该值。

//获取缓冲区的容量
public final int capacity() {
    return capacity;
}

filp 方法

public final Buffer flip() {
    limit = position;
    position = 0;
    mark = -1;
    return this;
}
  1. 将limit设置成当前position的坐标
  2. 将position设置为0
  3. 取消标记

rewind 方法

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

从源码中发现，rewind修改了position和mark,而没有修改limit。
1. 将position设置为0
2. 取消mark标记

clear 方法

    public final Buffer clear() {
        position = 0;
        limit = capacity;
        mark = -1;
        return this;
    }
  1. 将position坐标设置为0
  2. limit设置为capacity
  3. 取消标记

从clear方法中，我们发现Buffer中的数据没有清空，如果通过Buffer.get(i)的方式还是可以访问到数据的。如果再次向缓冲区中写入数据，他会覆盖之前存在的数据。

remaining 方法

查看当前位置和limit之间的元素数。

public final int remaining() {
    return limit - position;
}

hasRemaining 方法

判断当前位置和limit之间是否还有元素

public final boolean hasRemaining() {
    return position < limit;
}

ByteBuffer 类分析

ByteBuffer类结果图

从图中我们可以发现 ByteBuffer继承于Buffer类，ByteBuffer是个抽象类，它有两个实现的子类HeapByteBuffer和MappedByteBuffer类

HeapByteBuffer：在堆中创建的缓冲区。就是在jvm中创建的缓冲区。
MappedByteBuffer：直接缓冲区。物理内存中创建缓冲区，而不在堆中创建。

allocate 方法（创建堆缓冲区）

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

我们发现allocate方法创建的缓冲区是创建的HeapByteBuffer实例。

HeapByteBuffer 构造
HeapByteBuffer(int cap, int lim) {            // package-private
    super(-1, 0, lim, cap, new byte[cap], 0);
}

从堆缓冲区中看出，所谓堆缓冲区就是在堆内存中创建一个byte[]数组。

allocateDirect创建直接缓冲区

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

我们发现allocate方法创建的缓冲区是创建的DirectByteBuffer实例。

DirectByteBuffer构造

DirectByteBuffer 构造方法
直接缓冲区是通过java中Unsafe类进行在物理内存中创建缓冲区。

wrap 方法

public static ByteBuffer wrap(byte[] array)
public static ByteBuffer wrap(byte[] array, int offset, int length);

可以通过wrap类把字节数组包装成缓冲区ByteBuffer实例。
这里需要注意的的，把array的引用赋值给ByteBuffer对象中字节数组。如果array数组中的值更改，则ByteBuffer中的数据也会更改的。

get 方法

  1. public byte get()
    获取position坐标元素，并将position+1；
  2. public byte get(int i)
    获取指定索引下标的元素
  3. public ByteBuffer get(byte[] dst)
    从当前position中读取元素填充到dst数组中，每填充一个元素position+1;
  4. public ByteBuffer get(byte[] dst, int offset, int length)
    从当前position中读取元素到dst数组的offset下标开始填充length个元素。

put 方法

  1. public ByteBuffer put(byte x)
    写入一个元素并position+1
  2. public ByteBuffer put(int i, byte x)
    指定的索引写入一个元素
  3. public final ByteBuffer put(byte[] src)
    写入一个自己数组，并position+数组长度
  4. public ByteBuffer put(byte[] src, int offset, int length)
    从一个自己数组的offset开始length个元素写入到ByteBuffer中，并把position+length
  5. public ByteBuffer put(ByteBuffer src)
    写入一个ByteBuffer，并position加入写入的元素个数

视图缓冲区

Paste_Image.png
ByteBuffer可以转换成其它类型的Buffer。例如CharBuffer、IntBuffer 等。

压缩缓冲区

public ByteBuffer compact() {
        System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
        position(remaining());
        limit(capacity());
        discardMark();
        return this;
    }

1、把缓冲区positoin到limit中的元素向前移动positoin位
2、设置position为remaining()
3、 limit为缓冲区容量
4、取消标记

例如：ByteBuffer.allowcate(10);
内容：[0 ,1 ,2 ,3 4, 5, 6, 7, 8, 9]

compact前

[0 ,1 ,2 , 3, 4, 5, 6, 7, 8, 9]
pos=4
lim=10
cap=10

compact后

[4, 5, 6, 7, 8, 9, 6, 7, 8, 9]
pos=6
lim=10
cap=10

slice方法

public ByteBuffer slice() {
        return new HeapByteBuffer(hb,
                    -1,
                    0,
                    this.remaining(),
                    this.remaining(),
                    this.position() + offset);
}

创建一个分片缓冲区。分配缓冲区与主缓冲区共享数据。
分配的起始位置是主缓冲区的position位置
容量为limit-position。
分片缓冲区无法看到主缓冲区positoin之前的元素。

直接缓冲区和堆缓冲区性能对比

下面我们从缓冲区创建的性能和读取性能两个方面进行性能对比。

读写性能对比
public static void directReadWrite() throws Exception {
    int time = 10000000;
    long start = System.currentTimeMillis();
    ByteBuffer buffer = ByteBuffer.allocate(4*time);
    for(int i=0;i<time;i++){
        buffer.putInt(i);
    }
    buffer.flip();
    for(int i=0;i<time;i++){
        buffer.getInt();
    }
    System.out.println("堆缓冲区读写耗时  ："+(System.currentTimeMillis()-start));

    start = System.currentTimeMillis();
    ByteBuffer buffer2 = ByteBuffer.allocateDirect(4*time);
    for(int i=0;i<time;i++){
        buffer2.putInt(i);
    }
    buffer2.flip();
    for(int i=0;i<time;i++){
        buffer2.getInt();
    }
    System.out.println("直接缓冲区读写耗时："+(System.currentTimeMillis()-start));
}

输出结果：

堆缓冲区创建耗时  ：70
直接缓冲区创建耗时：47

从结果中我们发现堆缓冲区读写比直接缓冲区读写耗时更长。

#

public static void directAllocate() throws Exception {
    int time = 10000000;
    long start = System.currentTimeMillis();
    for (int i = 0; i < time; i++) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
    }
    System.out.println("堆缓冲区创建时间："+(System.currentTimeMillis()-start));

    start = System.currentTimeMillis();
    for (int i = 0; i < time; i++) {
        ByteBuffer buffer = ByteBuffer.allocateDirect(4);
    }
    System.out.println("直接缓冲区创建时间："+(System.currentTimeMillis()-start));
}

输出结果：

堆缓冲区创建时间：73
直接缓冲区创建时间：5146

从结果中发现直接缓冲区创建分配空间比较耗时。

对比结论

直接缓冲区比较适合读写操作，最好能重复使用直接缓冲区并多次读写的操作。
堆缓冲区比较适合创建新的缓冲区，并且重复读写不会太多的应用。

建议：如果经过性能测试，发现直接缓冲区确实比堆缓冲区效率高才使用直接缓冲区，否则不建议使用直接缓冲区。

本人简书blog地址：http://www.jianshu.com/u/1f0067e24ff8    
点击这里快速进入简书

GIT地址：http://git.oschina.net/brucekankan/
点击这里快速进入GIT

汲建帅
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NIO(byteBuffer)按行读取文件
08-31
使用nio byteBuffer 实现按行读取文件(大文件) 在window/linux/macOS上均测试通过 对于中文乱码也已处理成功 完整注释，可随需求更改 有问题请邮件:[email protected]
fork()+print()函数分析
大灰狼吃树皮
11-24 528
多进程fork()函数，在遇到print()时，会把输出缓冲区复制一份。 printf某些内容时，操作系统仅仅是把该内容放到了stdout的缓冲队列里了,并没有实际的写到屏幕上。但是,只要看到有/n 或是EOF，或是主动刷出，或是缓冲区满，或是文件描述符关闭，或是exit，就会把数据从缓冲区中输出出来（flush） fork(); print("x"); fork(); print("x"); fork(); print("x"); 执行完第二行时程序的缓冲区是 缓冲区1：x 缓冲区2：x 执行完第四行
java allocate_Java中的ByteBufferallocate()方法
weixin_30572707的博客
03-04 771
可以使用java.nio.ByteBuffer类中的方法allocate()分配新的ByteBuffer。该方法需要一个参数，即缓冲区的容量。它返回分配的新的ByteBuffer。如果提供的容量为负，则抛出IllegalArgumentException。演示此的程序如下所示-示例importjava.nio.*;importjava.util.*;publicclassDemo{pub...
JVM源码分析中不得不提到的堆外内存
xuanwo007的博客
06-29 4739
今天碰到一个比较奇怪的问题，在设置了-XX:MaxDirectMemorySize=1G的前提下，然后统计所有DirectByteBuffer对象后面占用的内存达到了7G，远远超出阈值，这个问题很诡异，于是好好查了下原因，虽然最终发现是我们统计的问题，但是期间发现的其他一些问题还是值得分享一下的。 不得不提的DirectByteBuffer构造函数 打开DirectByteBuffer这个类，我们会发现有5个构造函数 DirectByteBuffer(int cap); DirectByt.
ByteBuffer的allocate()方法详解
热门推荐
weixin_44400390的博客
06-28 1万+
ByteBuffer的allocate()方法详解 allocate()方法用于分配缓冲区。但是如果是聚集写入,与分散读取,就需要注意这个大小设置, String property = System.getProperty("user.dir"); FileOutputStream FileOutputStream = new FileOutputStream(property ...
一文搞懂ByteBuffer使用与原理
m0_71777195的博客
04-05 3554
已知NIOChannelBuffer和Selector。那么Buffer的作用就是提供一个缓冲区，用于用户程序和Channel之间进行数据读写，也就是用户程序中可以使用Buffer向Channel写入数据，也可以使用Buffer从Channel读取数据。ByteBuffer是Buffer子类，是字节缓冲区，特点如下所示。大小不可变。一旦创建，无法改变其容量大小，无法扩容或者缩容；读写灵活。内部通过指针移动来实现灵活读写；支持堆上内存分配和直接内存分配。本文将对ByteBuffer的相关概念，常用。
Java NIO原理图文分析及代码实现
09-01
本文主要介绍Java NIO原理的知识，这里整理了详细资料及简单示例代码和原理图，有需要的小伙伴可以参考下
Socket 之 BIO、NIO、Netty 简单实现
01-16
《Socket 之 BIO、NIO、Netty 简单实现》博客附件。 博客地址：https://blog.csdn.net/Supreme_Sir/article/details/112725728
Java NIO工作原理的全面分析
09-05
JDK 1.4 中引入的新输入输出 (NIO) 库在标准 Java 代码中提供了高速的、面向块的 I/O。本实用教程从高级概念到底层的编程细节，非常详细地介绍了 NIO 库。您将学到诸如缓冲区和通道这样的关键 I/O 元素的知识，并...
Chronicle-Bytes：Chronicle Bytes具有与Java NIO的ByteBuffer类似的用途，具有许多扩展
02-25
Chronicle Bytes具有与Java NIO的ByteBuffer类似的用途，但具有一些扩展。 API支持。 64位大小 UTF-8和ISO-8859-1编码的字符串。 线程安全关闭堆内存操作。 通过引用计数确定性地释放资源。 压缩数据类型，...
NIO学习笔记
qq_32806781的博客
02-05 83
NIO Reactor
Netty——ByteBuffer（ByteBuffer的方法说明演示示例）
小志的博客
07-24 666
Netty——ByteBuffer（ByteBuffer的方法说明演示示例）
ByteBuffer使用揭秘
共勉
02-07 2145
揭秘NIO中ByteBuffer缓冲区的使用细节和常用操作场景示例
java bytes_Java Bytes 操作和类型转换 | 学步园
weixin_35764532的博客
02-12 445
public byte[] longToBytes(long x) {ByteBuffer buffer = ByteBuffer.allocate(8);buffer.putLong(x);return buffer.array();}public long bytesToLong(byte[] bytes) {ByteBuffer buffer = ByteBuffer.allocate(8)...
ByteBuffer详解
一场人生，一场梦
01-10 1万+
一、前言 前一篇文章我们介绍了Android中直播视频技术的基础大纲知识，这里就开始一一讲解各个知识点，首先主要来看一下视频直播中的一个重要的基础核心类：ByteBuffer，这个类看上去都知道了，是字节缓冲区处理字节的，这个类的功能非常强大，也在各个场景都有用到，比如网络数据底层处理，特别是结合网络通道信息处理的时候，还有就是后面要说到的OpenGL技术也要用到，当然在视频处理中也是很重要
【Java】NIO中ByteBuffer的slice()方法
Badme
07-15 991
【Java】NIO中ByteBuffer的slice()方法
Java NIO使用及原理分析（三）
party
07-17 192
转载自：李会军•宁静致远 在上一篇文章中介绍了缓冲区内部对于状态变化的跟踪机制，而对于NIO中缓冲区来说，还有很多的内容值的学习，如缓冲区的分片与数据共享，只读缓冲区等。在本文中我们来看一下缓冲区一些更细节的内容。 缓冲区的分配 在前面的几个例子中，我们已经看过了，在创建一个缓冲区对象时，会调用静态方法allocate()来指定缓冲区的容量，其实调用 allocate()相当于创建了一个指定大小...
【Java】ByteBuffer的duplicate、slice方法介绍及测试
最新发布
Badme
07-18 413
【Java】ByteBuffer的duplicate、slice方法介绍及测试
Java NIO系列教程（三） Buffer
weixin_34356138的博客
07-11 360
2019独角兽企业重金招聘Python工程师标准>>> ...
java.nio.bytebuffer的duplicate
05-11
`java.nio.ByteBuffer` 的 `duplicate()` 方法会创建一个新的 `ByteBuffer` 对象，与原始对象共享相同的底层数组和位置、限制和标记。这意味着，对其中一个 `ByteBuffer` 对象的更改将反映在另一个对象中。 以下是使用 `duplicate()` 方法创建 `ByteBuffer` 对象的示例代码： ```java ByteBuffer originalBuffer = ByteBuffer.allocate(10); ByteBuffer duplicateBuffer = originalBuffer.duplicate(); ``` 在这个例子中，`duplicateBuffer` 与 `originalBuffer` 共享相同的底层数组、位置、限制和标记。如果你更改 `originalBuffer` 的位置或限制，则 `duplicateBuffer` 的位置或限制也会相应更改。同样地，如果你在 `originalBuffer` 中写入数据，那么这些数据也会在 `duplicateBuffer` 中可见。 需要注意的是，通过 `duplicate()` 方法创建的 `ByteBuffer` 对象不是线程安全的，因此在多线程环境下使用时需要注意同步问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值