即日起在codingBlog上分享您的技术经验即可获得积分,积分可兑换现金哦。

Java语言 NIO系列3:缓冲区

编程语言 jim_cainiaoxiaolang 13℃ 0评论
本文目录
[隐藏]

1.前言

一直想把NIO系列的文章更新下去,只不过发现在入职支付宝后工作实在是忙,所以一直拖到现在。直接从一个学生过狗成为一名加班狗,好吧,这就是互联网公司的现状吧,但是每天都是充实的,而且发现其他的员工也基本非常乐意加班,难道这就是阿里的文化熏陶?!

废话不多说,还是进入今天的正题,在前面的文章中,我们已经对Java的NIO有了一个粗浅的认识——主要之为了支持非阻塞I/O的操作,之前的BIO则是阻塞的。因为异步性的引入,大大提高了Java在处理异步任务的效率。下面认识下NIO中的缓冲区:

2.认识缓冲区

缓冲区可以理解为存储固定数量的容器,这些数据可以在存储后被检索,缓冲区的数据可以被写满或者被释放,而这些操作的实现需要认识缓冲区的属性:容量(capacity)、上界(limit)、位置(position)和标记(mark)。这四个属性的关系可以用下图来表示:

理解缓冲区

理解好这张图,缓冲区的精髓就掌握的四五分了,还有四五分从哪里来呢?当然是实践中来了。这张图传达了如下的信息:

0 <= mark <= position <= limit <= capacity
  • 1

容量


容量是指缓冲区可以容纳的最大元素个数,这一容量在缓冲区被创建的时候就被指定了。

上界


就是缓冲区现存元素的计数

位置


下一个要被读取的元素的索引

标记


由于在读取过程中position的值是动态变化,如果在读到某一个位置的时候需要做一个标记以便下次继续读,就可以做一个“书签”,让mark的值等于当前读到的position的值。

在java.nio包中Buffer类是缓冲区的顶层类,其他的缓冲区类都是基于这个类展开的。一个缓冲区类的主要方法如下:

public abstract class Buffer {
    // 获取缓冲区的容量
    public final int capacity( );
    // 获取下一个将要被读取的元素的索引
    public final int position( );
    // 设置缓冲区的位置为新位置
    public final Buffer position (int newPositio);
    // 返回上界
    public final int limit( );
    // 设置新的上界
    public final Buffer limit (int newLimit);
    // 返回标记的值
    public final Buffer mark( );
    // 将position重置为mark的值
    public final Buffer reset( );
    // 清空对上界和位置的操作
    public final Buffer clear( );
    // 重置position为0并将上界设为远position的值
    public final Buffer flip( );
    // 将position设置0
    public final Buffer rewind( );
    // 返回剩余未读的元素个数
    public final int remaining( );
    // 判断是否还有未读的元素
    public final boolean hasRemaining( );
    // 判断是否是只读
    public abstract boolean isReadOnly( );
}
  • 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

作为一个缓冲区,肯定是需要存取数据的,但是在Buffer类中并没有get和put类似的方法,实际上Java 设计者将get和put方法放到子类实现了。这样设计主要是考虑到在只需要关心缓冲区钟部分数据的情况,因为在这种情况可能有不同的存取策略。

3.缓冲区实战

现在已经对缓冲区有了一个基本认识,缓冲区的操作主要涉及以下几个部分:

存取


翻转


释放


压缩


标记


比较


批量移动

存取、翻转和释放

在缓冲区存取元素,需要创建缓冲区,存取操作的两个核心方法是:get和put方法,完成翻转只需要调用flip方法。下面是一个简单示例:

package com.rhwayfun.patchwork.nio.buffer;

import java.nio.CharBuffer;

/**
 * @description: Buffer缓冲区演示
 * @author: rhwayfun
 * @since: 2016-05-21
 */
public class BufferFillDrain {

    // 位置
    private static int index = 0;
    // 需要填充入缓冲区字符串数组
    private static String[] strings = new String[]{
            "Hello, this is a buffer",
            "I am learning buffer",
            "It is a wonderful world"
    };

    public static void main(String[] args) {
        // 申请100字节的缓冲区
        CharBuffer buffer = CharBuffer.allocate(100);
        // 如果缓存区没有达到上界则可以继续填充
        while (fillBuffer(buffer)){
            // 缓冲区翻转
            // flip可以将上界设为当前position的位置
            // 并将position重置为0
            buffer.flip();
            // 从缓冲区释放数据
            drainBuffer(buffer);
            // 清空缓冲区
            // 调用clear方法可本质上干了两件事
            // 一:将上界limit设为容量大小的位置
            // 二:将position重置为0
            buffer.clear();
        }
    }

    private static void drainBuffer(CharBuffer buffer) {
        // 得到剩余的元素个数
        int count = buffer.remaining();
        for (int i = 0; i < count; i++){
            System.out.println(i + "--->" + buffer.get());
        }
    }

    private static boolean fillBuffer(CharBuffer buffer) {
        if (index >= strings.length) {
            return false;
        }
        // 依次放入每个字符串数组
        String s = strings[index++];
        for (int i = 0; i < s.length(); i++){
            buffer.put(s.charAt(i));
        }
        return true;
    }
}
  • 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

压缩


压缩使用在需要释放缓冲区的空间的场景,执行压缩需要调用compact方法。该方法的会首先将position位置之后的元素(如果没有调用flip方法的话)复制从0开始的位置上,而position位置及之后的元素保持不变,在进行元素复制的过程中position的值也会发生改变。压缩的过程可以用如下的图表示:

压缩

下面的代码有演示了这个过程:

package com.rhwayfun.patchwork.nio.buffer;

import java.nio.CharBuffer;

/**
 * @description: 使用compact方法释放一部分数据
 * @author: rhwayfun
 * @since: 2016-05-21
 */
public class BufferCompact {
    public static void main(String[] args) {
        String s = "hello";

        CharBuffer buffer = CharBuffer.allocate(10);
        for (int i = 0; i < s.length(); i++){
            buffer.put(s.charAt(i));
        }

        // 将第一个位置的字符h换为M,并填入一个新的字符w
        buffer.put(0,'M').put('w');

        // 现在缓冲区的元素是Mellow,position的位置是6,limit和capacity都是10
        // 调用flip方法得到有效元素的位置,其实也就是position的位置
        buffer.flip();

        // 将M和e两个个字符释放掉
        System.out.println("release char " + buffer.get());
        System.out.println("release char " + buffer.get());

        // 调用compact方法可以回收M和e字符占用的空间
        // 调用compact后position位置是4,
        // 0-3位置的字符依次是llow,4-5位置的字符依次是ow
        // 虽然4-5位置有字符,但是调用put方法后会被重写
        // 并且调用compact方法后limit又回到了capacity的位置,也就是10
        buffer.compact();

        // 将4-5位置的字符修改为ab
        buffer.put('a').put('b');

        // 输出缓冲区的元素,根据上面的分析,最后输出的字符应该是llowab
        // 需要先调用flip方法将position设为0,这样才能读到完整的字符
        buffer.flip();
        while (buffer.hasRemaining()){
            System.out.println("print output " + buffer.get());
        }
    }
}
  • 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

比较


缓冲区的比较可以使用equals方法,进行缓冲区的比较的意义在于检测缓冲区包含的数据是否相同。当然,缓冲区的比较也支持使用compareTo方法进行比较。如果buffer1.equals(buffer2)要返回true,那么需要满足以下条件才可以:

  • 两个对象类型相同。包含不同数据类型的 buffer 永远不会相等,而且 buffer绝不会等于非 buffer 对象。
  • 两个对象都剩余同样数量的元素。Buffer 的容量不需要相同,而且缓冲区中剩余数据的索引也不必相同。但每个缓冲区中剩余元素的数目(从位置到上界)必须相同。
  • 在每个缓冲区中应被 Get()函数返回的剩余数据元素序列必须一致。

下面的代码演示了进行缓冲区比较的过程:

package com.rhwayfun.patchwork.nio.buffer;

import java.nio.CharBuffer;

/**
 * @description: 使用equals方法比较两个缓冲区是否相等
 * @author: rhwayfun
 * @since: 2016-05-21
 */
public class BufferCompareWithEquals {
    public static void main(String[] args) {
        String s1 = "two com";
        String s2 = "com";
        CharBuffer buffer1 = CharBuffer.allocate(10);
        CharBuffer buffer2 = CharBuffer.allocate(10);
        for (int i = 0; i < s1.length(); i++){
            buffer1.put(s1.charAt(i));
        }
        // 调用flip方法后limit为7
        buffer1.flip();
        // 继续往缓冲区放入一个字符,当前position的位置是1
        buffer1.put('A');
        // 将当前位置设为4,也就是字符c开始的位置
        buffer1.position(4);

        /*System.out.print("buffer1: ");
        while (buffer1.hasRemaining()){
            System.out.print(buffer1.get() + " ");
        }*/


        for (int i = 0; i < s2.length();i++){
            buffer2.put(s2.charAt(i));
        }
        // limit的位置是3,position的位置是0
        buffer2.flip();
        // 现在执行put方法会把位置0的字符c替换为B
        buffer2.limit(4);
        buffer2.put(3,'B');
        buffer2.position(0);
        buffer2.limit(3);

        /*System.out.print("buffer2: ");
        while (buffer2.hasRemaining()){
            System.out.print(buffer2.get() + " ");
        }*/

        // 使用equals方法比较两个缓冲区是否相等
        // 必须满足三个条件才能返回true
        // 1)两个缓冲区的对象的类型必须相同
        // 2)缓冲区的元素不必完全相同,但是如果position到limit之间的元素不相同,也返回false
        // 3)每个缓冲区get方法得到元素序列必须一致

        System.out.println(buffer1.equals(buffer2));

        // 还可以使用compareTo方法比较两个缓冲区,但是如果两个缓冲区的元素的类型不一致,equals方法返回false
        // 而compareTo方法则直接抛出ClassCastException的异常
    }
}
  • 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

批量操作


在之前的get和put方法,一次只能支持操作一个元素,从效率的角度讲还是很低的,那么有没有批量操作的方法呢?在Buffer API中可以使用重载的get和put方法进行批量的操作。下面的代码演示了如何进行缓冲区的批量操作:

package com.rhwayfun.patchwork.nio.buffer;

import java.nio.CharBuffer;

/**
 * @description: 批量操作缓冲区
 * @author: rhwayfun
 * @since: 2016-05-21
 */
public class BufferBatchOperation {
    public static void main(String[] args) {
        copyToBigArray();
        copyToSmallArray();
        System.out.println();
        putStringToBuffer();
    }

    private static void copyToBigArray() {
        // 将一个缓冲区释放到一个大数组中
        String s = "hello,rhwayfun";
        CharBuffer buffer = CharBuffer.allocate(20);
        for (int i = 0; i < s.length(); i++){
            buffer.put(s.charAt(i));
        }
        buffer.flip();
        // 创建一个大数组
        char[] array = new char[100];
        // 如果直接使用get方法将元素释放到array数组中
        // 则实际上将数组的0位置到最后一个位置,这里是
        // 99,依次将缓冲区的元素释放到数组中。由于缓冲
        // 区的元素根本不够,所以会抛出BufferUnderflowException异常
        // buffer.get(array);
        int remaining = buffer.remaining();
        buffer.get(array,0,remaining);

        // 测试array数组
        for (char c : array){
            System.out.print(c + " ");
        }
    }

    private static void copyToSmallArray(){
        // 将一个缓冲区释放到一个大数组中
        String s = "hello,rhwayfun";
        CharBuffer buffer = CharBuffer.allocate(20);
        for (int i = 0; i < s.length(); i++){
            buffer.put(s.charAt(i));
        }
        buffer.flip();
        char[] array = new char[10];
        while (buffer.hasRemaining()){
            int length = Math.min(array.length,buffer.remaining());
            buffer.get(array,0,length);
        }
    }

    private static  void putStringToBuffer(){
        String s = "Good morning";
        CharBuffer buffer = CharBuffer.allocate(20);
        buffer.put(s);
        buffer.flip();
        while (buffer.hasRemaining()) {
            System.out.print(buffer.get() + " ");
        }
    }
}
  • 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

4.小结

通过以上的叙述以及针对缓冲区的也也演示操作,我们对缓冲区的掌握也更加深入了,其实对缓冲区的理解最关键的还是缓冲区的模型图。这个图理解了,掌握Buffer类的API也就驾轻就熟了。

转载请注明:CodingBlog » Java语言 NIO系列3:缓冲区

喜欢 (0)or分享 (0)
发表我的评论
取消评论

*

表情