直接内存实战

╰+哭是因爲堅強的太久メ 2023-01-23 12:54 3阅读 0赞

# 一 点睛 #

不是虚拟机运行时数据区的一部分，也不是《Java虚拟机规范》中定义的内存区域。

直接内存是在 Java 堆外的、直接向系统申请的内存区间。

来源于 NIO（JDK1.4 引入），通过存在堆中的 DirectByteBuffer 操作 Native 内存。

通常，访问直接内存的速度会优于Java 堆，即读写性能高。

*  因此出于性能考虑，读写频繁的场合可能会考虑使用直接内存。
 *  Java 的 NIO 库允许 Java 程序使用直接内存，用于数据缓冲区。

使用下列代码，直接分配本地内存空间

int BUFFER = 1024*1024*1024; // 1GB
    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);

# 二 非直接缓存区和直接缓存区 #

原来采用 BIO 的架构，我们需要从用户态切换成内核态。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70][]

NIO 的方式使用了直接缓存区的概念。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1][]

# 三 直接内存存在的问题 #

*  也可能导致 OutOfMemoryError 异常。
 *  由于直接内存在 Java 堆外，因此它的大小不会直接受限于 -Xmx 指定的最大堆大小，但是系统内存是有限的，Java 堆和直接内存的总和依然受限于操作系统能给出的最大内存。
 *  缺点

- 分配回收成本较高

- 不受 JVM 内存回收管理

*  直接内存大小可以通过 MaxDirectMemorySize 设置。
 *  如果不指定，默认与堆的最大值-Xmx 参数值一致。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 2][]

# 四 实战——查看直接内存的占用与释放 #

## 1 代码 ##

/**
    *  IO                  |   NIO (New IO / Non-Blocking IO)
    *  byte[] / char[]     |   Buffer
    *  Stream              |   Channel
    *
    * 查看直接内存的占用与释放
    */
    public class BufferTest {
        private static final int BUFFER = 1024 * 1024 * 1024; // 1GB
    
    
        public static void main(String[] args){
            // 直接分配本地内存空间
            ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
            System.out.println("直接内存分配完毕，请求指示！");
    
    
            Scanner scanner = new Scanner(System.in);
            scanner.next();
    
    
            System.out.println("直接内存开始释放！");
            byteBuffer = null;
            System.gc();
            scanner.next();
        }
    }

## 2 测试 ##

a 占用

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 3][]

b 释放

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 4][]

# 五 实战——IO 和 NIO 的性能测试 #

## 1 代码 ##

package com.atguigu.java;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    /**
    * IO 和 NIO 的性能测试
    * IO：54606
    * NIO：50244
    */
    public class BufferTest1 {
        private static final String TO = "F:\\test\\异界BD中字.mp4";
        private static final int _100Mb = 1024 * 1024 * 100;
    
        public static void main(String[] args) {
            long sum = 0;
            String src = "F:\\test\\test.mp4";
            for (int i = 0; i < 3; i++) {
                String dest = "F:\\test\\test_" + i + ".mp4";
    //            sum += io(src,dest); // 54606
                sum += directBuffer(src, dest); // 50244
            }
            System.out.println("总花费的时间为：" + sum);
        }
    
        private static long directBuffer(String src, String dest) {
            long start = System.currentTimeMillis();
            FileChannel inChannel = null;
            FileChannel outChannel = null;
            try {
                inChannel = new FileInputStream(src).getChannel();
                outChannel = new FileOutputStream(dest).getChannel();
    
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
                while (inChannel.read(byteBuffer) != -1) {
                    byteBuffer.flip(); // 修改为读数据模式
                    outChannel.write(byteBuffer);
                    byteBuffer.clear(); // 清空
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (inChannel != null) {
                    try {
                        inChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (outChannel != null) {
                    try {
                        outChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
            long end = System.currentTimeMillis();
            return end - start;
        }
    
        private static long io(String src, String dest) {
            long start = System.currentTimeMillis();
            FileInputStream fis = null;
            FileOutputStream fos = null;
            try {
                fis = new FileInputStream(src);
                fos = new FileOutputStream(dest);
                byte[] buffer = new byte[_100Mb];
                while (true) {
                    int len = fis.read(buffer);
                    if (len == -1) {
                        break;
                    }
                    fos.write(buffer, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            
            long end = System.currentTimeMillis();
            return end - start;
        }
    }

## 2 测试说明 ##

IO测试，花费了 54606 ms。

NIO测试，花费了 50244 ms。

# 六 实战——本地内存 OOM 测试 #

## 1 代码 ##

/**
    * 本地内存的OOM:  OutOfMemoryError: Direct buffer memory
    */
    public class BufferTest2 {
        private static final int BUFFER = 1024 * 1024 * 10; // 10MB
    
        public static void main(String[] args) {
            ArrayList<ByteBuffer> list = new ArrayList<>();
            int count = 0;
            try {
                while (true) {
                    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
                    list.add(byteBuffer);
                    count++;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                System.out.println(count);
            }
        }
    }

## 2 测试 ##

> 注意：传统的 Java 内存监控工具无法进行本地内存监控，可以用任务管理器查看。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 5][]

OOM后，控制台打印如下。

339
    Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
        at java.nio.Bits.reserveMemory(Bits.java:694)
        at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
        at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
        at com.atguigu.java.BufferTest2.main(BufferTest2.java:17)

# 七 实战—— MaxDirectMemorySize 设置测试 #

## 1 代码 ##

/**
    * -Xmx20m -XX:MaxDirectMemorySize=10m
    */
    public class MaxDirectMemorySizeTest {
        private static final long _1MB = 1024 * 1024;
    
        public static void main(String[] args) throws IllegalAccessException {
            Field unsafeField = Unsafe.class.getDeclaredFields()[0];
            unsafeField.setAccessible(true);
            Unsafe unsafe = (Unsafe)unsafeField.get(null);
            while(true){
                unsafe.allocateMemory(_1MB);
            }
        }
    }

## 2 测试 ##

设置为  \-Xmx20m -XX:MaxDirectMemorySize=10m ，控制台打印如下

Exception in thread "main" java.lang.OutOfMemoryError
        at sun.misc.Unsafe.allocateMemory(Native Method)
        at com.atguigu.java.MaxDirectMemorySizeTest.main(MaxDirectMemorySizeTest.java:20)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70]: /images/20221004/e0877cefd3da423b9230a2afa70c1155.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1]: /images/20221004/a22523f99dbf4633b13d7d06e315874f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 2]: /images/20221004/f5628301b15d4f7dac6e9b56240ccb25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 3]: /images/20221004/8fecf9f4d5d9440199f5167d1a9d78ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 4]: /images/20221004/6d52b93eb86747d19d27cf33dfd337e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 5]: /images/20221004/0ddc0d553b1c440c8baed61c6908fdd1.png