Java-NIO(2)

Java-NIO(2)

缓冲区

常规I/O操作存在很大缺点，主要是因为它们是阻塞的，而NIO正是为了解决常规I/O执行效率低的问题，采用非阻塞高性能运行的方式来避免出现笨拙的同步I/O带来的效率低的问题

缓冲区Buffer，在NIO的使用中地位很高，因为数据就是放到缓冲区，对数据进行处理的

NIO中的Buffer是一个用于存储基本数据类型的容器，它以类似于数组有序的方式来存储和组织数据，每个基本数据类型(除boolean)都有一个子类相对应

Buffer类

Buffer类及其子类都是抽象类，不能直接实例化，使用方式是将对应的数据类型的数组包装进入缓冲区，借助静态方法wrap实现

API

NIO缓冲区中，有四个重要的参数:

  • capacity-容量

  • limit-限制

  • position-位置

  • mark-标记

四个之间的大小关系


0 <= mark <= position <= limit <= capacity
capacity

代码包含元素的数量。值不能为负数，且不可更改

方法:



/**
* Returns this buffer's capacity.
*
* @return  The capacity of this buffer
*/
public final int capacity() {
return capacity;
}



public class T1 {


    public static void main(String[] args) {

        byte[] bytes = new byte[]{1,2,3};

        short[] shorts = new short[]{1,2,3,4};

        int[] ints = new int[]{1,2,3,4,5};

        long[] longs = new long[]{1,2,3,4,5,6};

        float[] floats = new float[]{1,2,3,4,5,6,7};

        double[] doubles = new double[]{1,2,3,4,5,6,7,8};

        char[] chars = new char[]{'a','b','c','d','e'};

        ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);

        ShortBuffer shortBuffer = ShortBuffer.wrap(shorts);

        IntBuffer intBuffer = IntBuffer.wrap(ints);

        LongBuffer longBuffer = LongBuffer.wrap(longs);

        FloatBuffer floatBuffer = FloatBuffer.wrap(floats);

        DoubleBuffer doubleBuffer = DoubleBuffer.wrap(doubles);

        CharBuffer charBuffer = CharBuffer.wrap(chars);

        print(byteBuffer);

        print(shortBuffer);

        print(intBuffer);

        print(longBuffer);

        print(floatBuffer);

        print(doubleBuffer);

        print(charBuffer);

    }

    private static void print(Buffer buffer) {

        System.out.println("Name : \n");

        System.out.println(buffer.getClass().getName() + "\n");

        System.out.println("Capacity : \n");

        System.out.println(buffer.capacity());

        System.out.println("----------------------------------");

    }

}

看下ByteBuffer中wrap方法:



//将字节数组包装到缓冲区中。
//新缓冲区将由给定的字节数组支持； 也就是说，对缓冲区的修改将导致数组被修改，反之亦然。 新缓冲区的容量和限制将为array.length，其位置为零，其标记为未定义，其字节顺序为BIG_ENDIAN。 它的支持数组将是给定的数组，其数组偏移量将为零。
public static ByteBuffer wrap(byte[] array) {
return wrap(array, 0, array.length);
}

limit

何为限制?缓冲区的限制代表了第一个不应该读取或者写入元素的index(索引)，limit不可以为负，且不可以大于capacity，假设position大于limit，那么将position设置为新的limit，假设mark已定义且大于新的limit，则丢弃mark

limit应用图示:

图1.png

测试:


public class T2 {

    public static void main(String[] args) {

        char[] chars = new char[]{'a','b','c','d','e'};

        CharBuffer charBuffer = CharBuffer.wrap(chars);

        System.out.println("capacity : \n");

        System.out.println(charBuffer.capacity());

        System.out.println("");

        System.out.println("Limit : \n");

        System.out.println(charBuffer.limit());

        System.out.println("");

        charBuffer.limit(3);

        System.out.println("设置调整之后 : \n");

        System.out.println("capacity : \n");

        System.out.println(charBuffer.capacity());

        System.out.println("");

        System.out.println("Limit : \n");

        System.out.println(charBuffer.limit());

        System.out.println("");

        charBuffer.put(0,'0');

        charBuffer.put(1,'1');

        charBuffer.put(2,'2');

        charBuffer.put(3,'3');//报错

        charBuffer.put(4,'4');

        charBuffer.put(5,'5');

        charBuffer.put(6,'6');
        
    }
}

Limit使用场景就是当反复向缓冲区存取数据时使用，如下图，第一次向缓冲区存储9个数据，然后读取全部9个数据，完成之后再进行第二次向缓冲区存储数据，第二次只存4个数据:

图2.png

当读取会出现问题，如果读取全部1 2 3 4 E F G H I是错误的，所以要结合limit限制读取的范围，在E设置Limit，实现读取1 2 3 4这4个正确的数据

position

何为位置?它代表下一个要读取或写入元素的index，不能为负，且不能大于limit

图示:

图3.png

position对应index为3，说明从此位置开始写入或者读取，直到limit结束


public class T3 {


    public static void main(String[] args) {

        char[] chars = new char[]{'a','b','c','d','e'};

        CharBuffer charBuffer = CharBuffer.wrap(chars);

        print(charBuffer);

        System.out.println("-----------");

        charBuffer.position(2);

        print(charBuffer);

        System.out.println("-----------");

        charBuffer.put('1');

        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i] + "   ");
        }
    }

    private static void print(Buffer buffer) {

        System.out.println("Capacity : " + buffer.capacity()

        +"   " + "limit :  " + buffer.limit() + "   "
        + "position : " + buffer.position());

    }
}

remaining

方法remaining作用:返回当前位置与limit之间的元素个数

图示:

图4.png

源码:



/**
* Returns the number of elements between the current position and the
* limit.
*
* @return  The number of elements remaining in this buffer
*/
public final int remaining() {
return limit - position;
}



public class T4 {

    public static void main(String[] args) {
        char[] chars = new char[]{'a','b','c','d','e'};

        CharBuffer charBuffer = CharBuffer.wrap(chars);

        print(charBuffer);

        System.out.println("-----------");

        charBuffer.position(2);

        print(charBuffer);

        System.out.println("-----------");

        System.out.println("remaining   " + charBuffer.remaining());

    }

    private static void print(Buffer buffer) {

        System.out.println("Capacity : " + buffer.capacity()

                +"   " + "limit :  " + buffer.limit() + "   "
                + "position : " + buffer.position());

    }
}

mark()

缓冲区位置设置标记

标记作用:缓冲区的标记是一个索引，在调用reset方法时，会将缓冲区的position位置重置为该索引

缓冲区的mark类似于爬山时在关键路口设置路标，为了在原路返回时找到回去的路



public class T6 {

    public static void main(String[] args) {


        char[] chars = new char[]{'a','b','c','d','e'};

        CharBuffer charBuffer = CharBuffer.wrap(chars);

        System.out.println("capacity        " + charBuffer.capacity());

        charBuffer.position(1);

        charBuffer.mark(); // 位置1设置标记

        System.out.println("position        " + charBuffer.position());

        System.out.println("-----------");


        charBuffer.position(2);

        System.out.println("position        " + charBuffer.position());


        charBuffer.reset();

        System.out.println("---------");

        System.out.println("reset \n");
        System.out.println("position        " + charBuffer.position());


    }
}

判断只读


public class T7 {

    public static void main(String[] args) {

        byte[] bytes = new byte[]{1,2,3};

        short[] shorts = new short[]{1,2,3,4};

        int[] ints = new int[]{1,2,3,4,5};

        long[] longs = new long[]{1,2,3,4,5,6};

        float[] floats = new float[]{1,2,3,4,5,6,7};

        double[] doubles = new double[]{1,2,3,4,5,6,7,8};

        char[] chars = new char[]{'a','b','c','d','e'};

        ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);

        ShortBuffer shortBuffer = ShortBuffer.wrap(shorts);

        IntBuffer intBuffer = IntBuffer.wrap(ints);

        LongBuffer longBuffer = LongBuffer.wrap(longs);

        FloatBuffer floatBuffer = FloatBuffer.wrap(floats);

        DoubleBuffer doubleBuffer = DoubleBuffer.wrap(doubles);

        CharBuffer charBuffer = CharBuffer.wrap(chars);

        print(byteBuffer);
        print(shortBuffer);
        print(intBuffer);
        print(longBuffer);
        print(floatBuffer);
        print(doubleBuffer);
        print(charBuffer);
    }

    private static void print(Buffer buffer) {
        System.out.println("is readOnly ? : \n" +
                buffer.isReadOnly());
    }
}

直接缓冲区

何为直接与非直接缓冲区?

图示:

![图6.png](https://upload-images.jianshu.io/upload_images/5653258-da305755b6ef552d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

使用非直接缓冲区存取数据，需要将数据暂存在JVM的中间缓冲区，如果有频繁的数据操作，则会大大降低软件对于数据的吞吐量，效率低下，所以就使用直接缓冲区来解决这个问题


public class T8 {

    public static void main(String[] args) {

        ByteBuffer byteBuffer = ByteBuffer.allocate(100);

        System.out.println(byteBuffer.isDirect());

        ByteBuffer byteBuffer1 = ByteBuffer.allocateDirect(100);

        System.out.println(byteBuffer1.isDirect());

    }
}

还原缓冲区状态

final Buffer clear():

还原缓冲区到初始状态:

  • 位置设为0

  • 限制设为容量

  • 丢弃标记

源码实现:


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

此方法使用场景就是在对缓存区存储数据之前调用此方法，如:


buf.clear();

in.read(buf);

但clear方法不是真正的清除缓存区中的数据，它的清除是通过将position位置归0，再执行写入新数据的代码，将最新数据由索引位置0开始进行覆盖，新值覆盖旧值，间接的清除数据


public class T9 {


    public static void main(String[] args) {

        byte[] bytes = new byte[]{1,2,3,4,5,6,7};

        ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);

        byteBuffer.position(2);
        byteBuffer.limit(3);
        byteBuffer.mark();

        byteBuffer.clear();

        System.out.println("position: \n" + byteBuffer.position());

        System.out.println("");

        System.out.println("limit : \n" + byteBuffer.limit());

        System.out.println("");
        
    }
}

缓冲区反转

源码:



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

效果:

  • 限制设为当前位置

  • 位置设为0

  • 如果定义了标记就丢弃

当向缓冲区存储数据，然后再从缓冲区读取数据时，就是使用flip方法的好地方:



A : buf.allocate(10);

B : buf.put(8);

C : 先向buf写入数据

D : buf.flip();

E : 再从buf读数据

图示:


图6.png



public class T2 {

    public static void main(String[] args) {

        CharBuffer charBuffer = CharBuffer.allocate(20);

        print(charBuffer);

        charBuffer.put(" I am from China");

        System.out.println("-----------------------------");
        print(charBuffer);
        System.out.println("-----------------------------");
        charBuffer.position(0);
        print(charBuffer);
        System.out.println("-----------------------------");

        // 以下循环多输出了6个空格 为无效的数据
        // 正确的应该是只打印前面有效的字符 空格不在输出
        for (int i = 0; i < charBuffer.limit(); i++) {
            System.out.println(charBuffer.get());
        }

        /*
        上面为错误的读取数据示例
         */
        System.out.println("-----------------------------");

        print(charBuffer);
        System.out.println("-----------------------------");

        // 还原缓冲区状态
        charBuffer.clear();

        print(charBuffer);
        System.out.println("-----------------------------");

        charBuffer.put(" I ams usa");

        print(charBuffer);
        System.out.println("-----------------------------");

        /*
        以下操作是自己手动实现了 flip方法的逻辑
         */
        charBuffer.limit(charBuffer.position());

        charBuffer.position(0);

        print(charBuffer);
        System.out.println("-----------------------------");

        for (int i = 0; i < charBuffer.limit(); i++) {
            System.out.println(charBuffer.get());
        }

    }

    private static void print(Buffer buffer){
        System.out.println("position : \n"
        + buffer.position()
        +"\n"
        +"limit : \n"
        +buffer.limit());
    }
}

判断是否有底层实现的数组

源码:


public final boolean hasArray() {
    return (hb != null) && !isReadOnly;
}



public class T3 {

    public static void main(String[] args) {

        ByteBuffer byteBuffer = ByteBuffer.allocate(100);

        byteBuffer.put((byte) 1);
        byteBuffer.put((byte) 2);

        System.out.println(byteBuffer.hasArray());

        /* 对直接缓冲区判断 */

        ByteBuffer dircet_byteBuffer = ByteBuffer.allocateDirect(100);
        dircet_byteBuffer.put((byte) 1);
        dircet_byteBuffer.put((byte) 2);
        System.out.println(dircet_byteBuffer.hasArray());

    }
}

  • 打印true是因为使用了byte[] hb存储数据，所以hb[]对象为非空，结果就是true

  • 打印false是因为代表byte[] hb数组为null，数据直接存在内存了

判断当前位置与限制之间是否还有剩余元素

源码:


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

以及返回当前位置与限制之间的元素个数:


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



    public static void main(String[] args) {

        byte[] bytes = new byte[]{1,2,3,4,5};

        ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);

        byteBuffer.limit(3);

        byteBuffer.position(2);

        System.out.println("hasRemainging : \n"
        +byteBuffer.hasRemaining()
        +"Remainging : \n"
        +byteBuffer.remaining());


    }

重绕缓冲区

源码实现:

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

在一系列通道重新写入或获取的操作之前调用此方法:

     
out.write(buf);    // Write remaining data
buf.rewind();      // Rewind buffer
buf.get(array);    // Copy data into array</pre></blockquote>

rewind():标记清除，位置position归0，limit不变

rewind经常在重新读取缓冲区数据时使用

而clear()方法主要使用场景是在对缓冲区进行存储数据之前调用

flip()是缩小limit范围

三者侧重点不同:

  • rewind:侧重于在“重新”，在重新读取，重新写入时使用

  • clear():侧重于还原一切状态

  • flip():侧重于substring截取


public class T5 {

    public static void main(String[] args) {

        byte[] bytes = new byte[]{1,2,3,4,5,6,7,8};

        ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);

        print(byteBuffer);

        System.out.println("");

        byteBuffer.position(1);
        byteBuffer.limit(3);
        byteBuffer.mark();

        print(byteBuffer);

        System.out.println("");

        byteBuffer.rewind();

        print(byteBuffer);

        byteBuffer.reset();


    }
    private static void print(Buffer buffer){
        System.out.println("capacity : \n"
                + buffer.capacity()
                +"\n"
                +"limit : \n"
                +buffer.limit()
        +"\n"
        +"position : \n"
        + buffer.position());
    }
}

List.toArray(T[])转出数组类型


public class T6 {

    public static void main(String[] args) {

        ByteBuffer b1 = ByteBuffer.wrap(new byte[]{'1','2','3'});
        ByteBuffer b2 = ByteBuffer.wrap(new byte[]{'1','2','3'});
        ByteBuffer b3 = ByteBuffer.wrap(new byte[]{'1','2','3'});
        ByteBuffer b4 = ByteBuffer.wrap(new byte[]{'1','2','3'});
        ByteBuffer b5 = ByteBuffer.wrap(new byte[]{'1','2','3'});

        List<ByteBuffer> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(b3);
        list.add(b4);
        list.add(b5);

        ByteBuffer[] byteBuffers = new ByteBuffer[list.size()];
        list.toArray(byteBuffers);

        System.out.println("--------------------------");

        
        System.out.println(byteBuffers.length);

        for (int i = 0; i < byteBuffers.length; i++) {

            ByteBuffer byteBuffer = byteBuffers[i];

            while (byteBuffer.hasRemaining()) {

                System.out.println((char)byteBuffer.get());

            }

            System.out.println("--------------------------");

        }



    }
}

参考资料

《NIO与Socket编程技术指南》

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,686评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,668评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 158,160评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,736评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,847评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,043评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,129评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,872评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,318评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,645评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,777评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,470评论 4赞 333
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,126评论 3赞 317
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,861评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,095评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,589评论 2赞 362
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,687评论 2赞 351

推荐阅读更多精彩内容