码迷,mamicode.com
首页 > 其他好文 > 详细

NIO基础之Buffer

时间:2019-05-13 09:21:53      阅读:105      评论:0      收藏:0      [点我收藏+]

标签:空间   Locator   dom   unsafe   系统   转换   元素   内存映射文件   byte   

java.io 核心概念是流,即面向流的编程,在java中一个流只能是输入流或者输出流,不能同时具有两个概念。

java.nio核心是 selector、Channel、Buffer ,是面向缓冲区(buffer)或者面向块block。

一、Buffer 

Buffer本身是一个内存块,底层是数组,数据的读写都是通过Buffer类实现的。即同一个Buffer即可以写数据也可以读数据,通过intBuffer.flip()方法进行Buffer位置状态的翻转。JAVA中的8中基本类型都有各自对应的Buffer。

缓冲区buffer主要是和通道数据交互,即从通道中读入数据到缓冲区,和从缓冲区中把数据写入到通道中,通过这样完成对数据的传输。 它通过几个变量来保存这个数据的当前位置状态。

Buffer中的四个核心变量

  • 容量(Capacity):缓冲区能够容纳的数据元素的最大数量。这一个容量在缓冲区创建时被设定,并且永远不能改变。
  • 界限(Limit):指定还有多少数据需要取出(在从缓冲区写入通道时),或者还有多少空间可以放入数据(在从通道读入缓冲区时)。
  • 位置(Position):指定了下一个将要被写入或者读取的元素索引,它的值由get()/put()方法自动更新,在新创建一个Buffer对象时,position被初始化为0。
  • 标记(Mark):下一个要被读或写的元素的索引。位置会自动由相应的 get( )和 put( )函数更新

get()方法从缓冲区中读取数据写入到输出通道,这会导致position的增加而limit保持不变,但position不会超过limit的值。

flip()方法 把limit设置为当前的position值 并且把position设置为 0

clear()方法将Buffer恢复到初始化状态

public class BufferTest {
    public static void main(String[] args) throws IOException {
        ByteBufferTest();
    }
    private static void  ByteBufferTest(){
        //分配新的byte缓冲区,参数为缓冲区容量
        //新缓冲区的当前位置将为零,其界限(限制位置)将为其容量,它将具有一个底层实现数组,其数组偏移量将为零。
        ByteBuffer byteBuffer=ByteBuffer.allocate(10);
        output("初始化缓冲区:",byteBuffer);
        for(int i=0;i<byteBuffer.capacity()-1;i++){
            byteBuffer.put(Byte.parseByte(new SecureRandom().nextInt(20)+""));
        }
        output("写入缓冲区9个byte:",byteBuffer);
        byteBuffer.flip();
        output("使用flip重置元素位置:",byteBuffer);
        while (byteBuffer.hasRemaining()){
            System.out.print(byteBuffer.get()+"|");
        }
        System.out.print("\n");
        output("使用get读取元素:",byteBuffer);
        byteBuffer.clear();
        output("恢复初始化态clear:",byteBuffer);

    }
    private static void output(String step, Buffer buffer) {
        System.out.println(step + " : ");
        System.out.print("capacity: " + buffer.capacity() + ", ");
        System.out.print("position: " + buffer.position() + ", ");
        System.out.println("limit: " + buffer.limit());
        System.out.println("mark: " + buffer.mark());
        System.out.println();
    }
}
初始化缓冲区: : 
capacity: 10, position: 0, limit: 10
mark: java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]

写入缓冲区9个byte: : 
capacity: 10, position: 9, limit: 10
mark: java.nio.HeapByteBuffer[pos=9 lim=10 cap=10]

使用flip重置元素位置: : 
capacity: 10, position: 0, limit: 9
mark: java.nio.HeapByteBuffer[pos=0 lim=9 cap=10]

读取元素:1|读取元素:16|读取元素:12|读取元素:0|读取元素:17|读取元素:5|读取元素:4|读取元素:13|读取元素:18|
使用get读取元素后: : 
capacity: 10, position: 9, limit: 9
mark: java.nio.HeapByteBuffer[pos=9 lim=9 cap=10]

恢复初始化态clear: : 
capacity: 10, position: 0, limit: 10
mark: java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]

 ByteBuffer.wrap( array ):将一个现有的数组,包装为缓冲区对象

 buffer.slice():创建子缓冲区,子缓冲区与原缓冲区是数据共享的

buffer.position( 3 );
buffer.limit( 7 );
ByteBuffer slice = buffer.slice();

 只读缓冲区:ByteBuffer readonly = buffer.asReadOnlyBuffer();

     只读缓冲区非常简单,可以读取它们,但是不能向它们写入数据。可以通过调用缓冲区的asReadOnlyBuffer()方法,将任何常规缓冲区转 换为只读缓冲区,这个方法返回一个与原缓冲区完全相同的缓冲区,并与原缓冲区共享数据,只不过它是只读的。如果原缓冲区的内容发生了变化,只读缓冲区的内容也随之发生变化。

    如果尝试修改只读缓冲区的内容,则会报ReadOnlyBufferException异常。只读缓冲区对于保护数据很有用。创建一个只读的缓冲区可以保证该缓冲区不会被修改。只可以把常规缓冲区转换为只读缓冲区,而不能将只读的缓冲区转换为可写的缓冲区。

 

二、直接缓冲区 DirectByteBuffer

   直接在堆外分配一个内存(即,native memory)来存储数据,程序通过JNI直接将数据读/写到堆外内存中。因为数据直接写入到了堆外内存中,所以这种方式就不会再在JVM管控的堆内再分配内存来存储数据了,也就不存在堆内内存和堆外内存数据拷贝的操作了。这样在进行I/O操作时,只需要将这个堆外内存地址传给JNI的I/O的函数就好了。底层的数据其实是维护在操作系统的内存中,而不是jvm里,DirectByteBuffer里维护了一个引用address指向了数据,从而操作数据。实现zero copy(零拷贝)。

       间接内存HeapByteBuffer:对于HeapByteBuffer,数据的分配存储都在jvm堆上,当需要和io设备打交道的时候,会将jvm堆上所维护的byte[]拷贝至堆外内存,然后堆外内存直接和io设备交互。外设之所以要把jvm堆里的数据copy出来再操作,不是因为操作系统不能直接操作jvm内存,而是因为jvm在进行gc(垃圾回收)时,会对数据进行移动,一旦出现这种问题,外设就会出现数据错乱的情况。

直接缓冲区的创建:ByteBuffer buffer = ByteBuffer.allocateDirect( 1024 );

DirectByteBuffer的初始化:

 DirectByteBuffer(int cap) {                   // package-private
        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 {
             // 通过unsafe.allocateMemory分配堆外内存,并返回堆外内存的基地址
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
         // 构建Cleaner对象用于跟踪DirectByteBuffer对象的垃圾回收,以实现当DirectByteBuffer被垃圾回收时,堆外内存也会被释放
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }

 // Used only by direct buffers
    // NOTE: hoisted here for speed in JNI GetDirectBufferAddress
    //address就是堆外内存创建好后返回给JVM的地址,JVM内存需要维护的只是DirectByteBuffer对象,而具体数据的管理是由操作系统来管理的
    long address;

什么情况下使用堆外内存

  • 堆外内存适用于生命周期中等或较长的对象。( 如果是生命周期较短的对象,在YGC的时候就被回收了,就不存在大内存且生命周期较长的对象在FGC对应用造成的性能影响 )。
  • 直接的文件拷贝操作,或者I/O操作。直接使用堆外内存就能少去内存从用户内存拷贝到系统内存的操作,因为I/O操作是系统内核内存和设备间的通信,而不是通过程序直接和外设通信的。
  • 同时,还可以使用 池+堆外内存 的组合方式,来对生命周期较短,但涉及到I/O操作的对象进行堆外内存的再使用。( Netty中就使用了该方式 )

两种方式的效率比较:技术图片技术图片

private static void directByteBufferTest()throws IOException{
        long start=System.currentTimeMillis();
        FileInputStream is=new FileInputStream("F:\\logs\\1g.rar");
        FileOutputStream fos=new FileOutputStream("F:\\logs\\2g.rar");
        FileChannel fcIs,fcOut;
        fcIs=is.getChannel();
        fcOut=fos.getChannel();
        ByteBuffer directByteBuffer= ByteBuffer.allocateDirect(2048);
        while (fcIs.read(directByteBuffer)!=-1){
            directByteBuffer.flip();
            fcOut.write(directByteBuffer);
            directByteBuffer.clear();
        }
        is.close();
        fos.close();
        long end=System.currentTimeMillis();
        System.out.println("DirectByteBuffer需要时间:"+(end-start));
    }
    private static void heapByteBufferTest()throws IOException{
        long start=System.currentTimeMillis();
        FileInputStream is=new FileInputStream("F:\\logs\\1g.rar");
        FileOutputStream fos=new FileOutputStream("F:\\logs\\3g.rar");
        FileChannel fcIs,fcOut;
        fcIs=is.getChannel();
        fcOut=fos.getChannel();
        ByteBuffer directByteBuffer= ByteBuffer.allocate(2048);
        while (fcIs.read(directByteBuffer)!=-1){
            directByteBuffer.flip();
            fcOut.write(directByteBuffer);
            directByteBuffer.clear();
        }
        is.close();
        fos.close();
        long end=System.currentTimeMillis();
        System.out.println("HeapByteBuffer需要时间:"+(end-start));
    }

17行输出:DirectByteBuffer需要时间:30456

35行输出:HeapByteBuffer需要时间:45285

 三、内存映射文件I/O   MappedByteBuffer

 

 内存映射文件I/O是一种读和写文件数据的方法,它可以比常规的基于流或者基于通道的I/O快的多。内存映射文件I/O是通过使文件中的数据出现为 内存数组的内容来完成的,这其初听起来似乎不过就是将整个文件读到内存中,但是事实上并不是这样。一般来说,只有文件中实际读取或者写入的部分才会映射到内存中。

FileChannel提供了map方法来把文件影射为内存映像文件: MappedByteBuffer map(int mode,long position,long size); 可以把文件的从position开始的size大小的区域映射为内存映像文件,映射内存缓冲区是个直接缓冲区,继承自ByteBuffer,但相对于ByteBuffer,它有更多的优点 读取快 写入快  随时随地写入;

mode指出了 可访问该内存映像文件的方式:            
    1、READ_ONLY,(只读): 试图修改得到的缓冲区将导致抛出 ReadOnlyBufferException.(MapMode.READ_ONLY)

    2、READ_WRITE(读/写): 对得到的缓冲区的更改最终将传播到文件;该更改对映射到同一文件的其他程序不一定是可见的。 (MapMode.READ_WRITE)
    3、PRIVATE(专用): 对得到的缓冲区的更改不会传播到文件,并且该更改对映射到同一文件的其他程序也不是可见的;相反,会创建缓冲区已修改部分的专用副本。 (MapMode.PRIVATE)

MappedByteBuffer 中的三个方法:

    a. fore();缓冲区是READ_WRITE模式下,此方法对缓冲区内容的修改强行写入文件
    b. load()将缓冲区的内容载入内存,并返回该缓冲区的引用
    c. isLoaded()如果缓冲区的内容在物理内存中,则返回真,否则返回假

使用MappedByteBuffer 将数据写入文件:

private static void mappedOutFile()throws IOException{
        String str="I Love MappedByteBuffer";
        RandomAccessFile raf = new RandomAccessFile( filePath, "rw" );
        FileChannel fc = raf.getChannel();
        byte [] msg=str.getBytes("UTF-8");
        MappedByteBuffer mbb = fc.map( FileChannel.MapMode.READ_WRITE, 0, msg.length);
        mbb.put(msg);
        fc.write(mbb);
        raf.close();
    }

 

NIO基础之Buffer

标签:空间   Locator   dom   unsafe   系统   转换   元素   内存映射文件   byte   

原文地址:https://www.cnblogs.com/jalja/p/10854511.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!