java堆外内存存放什么 java堆外内存使用场景

转载

墨染青衫 2024-02-22 07:37:29

文章标签 java堆外内存存放什么 ide 缓存堆内存 文章分类 Java 后端开发

java堆外内存存放什么 java堆外内存使用场景_堆内存

RxCache

RxCache 是一款支持 Java 和 Android 的 Local Cache 。目前，支持堆内存、堆外内存(off-heap memory)、磁盘缓存。

github地址：https://github.com/fengzhizi715/RxCache

堆外内存(off-heap memory)

对象可以存储在堆内存、堆外内存、磁盘缓存甚至是分布式缓存。

在 Java 中，与堆外内存相对的是堆内存。堆内存遵守 JVM 的内存管理机制，而堆外内存不受到此限制，它由操作系统进行管理。

java堆外内存存放什么 java堆外内存使用场景_堆内存_02

堆外内存和堆内存有明显的区别，或者说有相反的应用场景。

堆外内存更适合：

存储生命周期长的对象
可以在进程间可以共享，减少 JVM 间的对象复制，使得 JVM 的分割部署更容易实现。
本地缓存，减少磁盘缓存或者分布式缓存的响应时间。

RxCache 中使用的堆外内存

首先，创建一个 DirectBufferConverter ，用于将对象和 ByteBuffer 相互转换，以及对象和byte数组相互转换。其中，ByteBuffer.allocteDirect(capability) 用于分配堆外内存。Cleaner 是自己定义的一个类，用于释放 DirectByteBuffer。具体代码可以查看：https://github.com/fengzhizi715/RxCache/blob/master/offheap/src/main/java/com/safframework/rxcache/offheap/converter/Cleaner.java

public abstract class DirectBufferConverter<V> {
1. 
    public void dispose(ByteBuffer direct) {
1. 
        Cleaner.clean(direct);    }
1. 
    public ByteBuffer to(V from) {        if(from == null) return null;
1. 
        byte[] bytes = toBytes(from);        ByteBuffer.wrap(bytes);        ByteBuffer bf = ByteBuffer.allocateDirect(bytes.length);        bf.put(bytes);        bf.flip();        return bf;    }
1. 
    abstract public byte[] toBytes(V value);
1. 
    abstract public V toObject(byte[] value);
1. 
    public V from(ByteBuffer to) {        if(to == null) return null;
1. 
        byte[] bs = new byte[to.capacity()];        to.get(bs);        to.flip();        return toObject(bs);    }
1. 
}

接下来，定义一个 ConcurrentDirectHashMap实现Map接口。它是一个范性，支持将 V 转换成 ByteBuffer 类型，存储到 ConcurrentDirectHashMap 的 map 中。

public abstract class ConcurrentDirectHashMap<K, V> implements Map<K, V> {
1. 
    final private Map<K, ByteBuffer> map;
1. 
    private final DirectBufferConverter<V> converter = new DirectBufferConverter<V>() {
1. 
        @Override        public byte[] toBytes(V value) {            return convertObjectToBytes(value);        }
1. 
        @Override        public V toObject(byte[] value) {            return convertBytesToObject(value);        }    };
1. 
    ConcurrentDirectHashMap() {
1. 
        map = new ConcurrentHashMap<>();    }
1. 
    ConcurrentDirectHashMap(Map<K, V> m) {
1. 
        map = new ConcurrentHashMap<>();
1. 
        for (Entry<K, V> entry : m.entrySet()) {            K key = entry.getKey();            ByteBuffer val = converter.to(entry.getValue());            map.put(key, val);        }    }
1. 
    protected abstract byte[] convertObjectToBytes(V value);
1. 
    protected abstract V convertBytesToObject(byte[] value);
1. 
    @Override    public int size() {        return map.size();    }
1. 
    @Override    public boolean isEmpty() {        return map.isEmpty();    }
1. 
    @Override    public boolean containsKey(Object key) {        return map.containsKey(key);    }
1. 
    @Override    public V get(Object key) {        final ByteBuffer byteBuffer = map.get(key);        return converter.from(byteBuffer);    }
1. 
    @Override    public V put(K key, V value) {        final ByteBuffer byteBuffer = map.put(key, converter.to(value));        converter.dispose(byteBuffer);        return converter.from(byteBuffer);    }
1. 
    @Override    public V remove(Object key) {        final ByteBuffer byteBuffer = map.remove(key);        final V value = converter.from(byteBuffer);        converter.dispose(byteBuffer);        return value;    }
1. 
    @Override    public void putAll(Map<? extends K, ? extends V> m) {        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {            ByteBuffer byteBuffer = converter.to(entry.getValue());            map.put(entry.getKey(), byteBuffer);        }    }
1. 
    @Override    public void clear() {        final Set<K> keys = map.keySet();
1. 
        for (K key : keys) {            map.remove(key);        }    }
1. 
    @Override    public Set<K> keySet() {        return map.keySet();    }
1. 
    @Override    public Collection<V> values() {        Collection<V> values = new ArrayList<>();
1. 
        for (ByteBuffer byteBuffer : map.values())        {            V value = converter.from(byteBuffer);            values.add(value);        }        return values;    }
1. 
    @Override    public Set<Entry<K, V>> entrySet() {        Set<Entry<K, V>> entries = new HashSet<>();
1. 
        for (Entry<K, ByteBuffer> entry : map.entrySet()) {            K key = entry.getKey();            V value = converter.from(entry.getValue());
1. 
            entries.add(new Entry<K, V>() {                @Override                public K getKey() {                    return key;                }
1. 
                @Override                public V getValue() {                    return value;                }
1. 
                @Override                public V setValue(V v) {                    return null;                }            });        }
1. 
        return entries;    }
1. 
    @Override    public boolean containsValue(Object value) {
1. 
        for (ByteBuffer v : map.values()) {            if (v.equals(value)) {                return true;            }        }        return false;    }}

创建 ConcurrentStringObjectDirectHashMap，它的 K 是 String 类型，V 是任意的 Object 对象。其中，序列化和反序列化采用《Java 字节的常用封装》提到的 bytekit。

public class ConcurrentStringObjectDirectHashMap extends ConcurrentDirectHashMap<String,Object> {
1. 
    @Override    protected byte[] convertObjectToBytes(Object value) {
1. 
        return Bytes.serialize(value);    }
1. 
    @Override    protected Object convertBytesToObject(byte[] value) {
1. 
        return Bytes.deserialize(value);    }}

基于 FIFO 以及堆外内存来实现 Memory 级别的缓存。

public class DirectBufferMemoryImpl extends AbstractMemoryImpl {
1. 
    private ConcurrentStringObjectDirectHashMap cache;    private List<String> keys;
1. 
    public DirectBufferMemoryImpl(long maxSize) {
1. 
        super(maxSize);        cache = new ConcurrentStringObjectDirectHashMap();        this.keys = new LinkedList<>();    }
1. 
    @Override    public <T> Record<T> getIfPresent(String key) {
1. 
        T result = null;
1. 
        if(expireTimeMap.get(key)!=null) {
1. 
            if (expireTimeMap.get(key)<0) { // 缓存的数据从不过期
1. 
                result = (T) cache.get(key);            } else {
1. 
                if (timestampMap.get(key) + expireTimeMap.get(key) > System.currentTimeMillis()) {  // 缓存的数据还没有过期
1. 
                    result = (T) cache.get(key);                } else {                     // 缓存的数据已经过期
1. 
                    evict(key);                }            }        }
1. 
        return result != null ? new Record<>(Source.MEMORY,key, result, timestampMap.get(key),expireTimeMap.get(key)) : null;    }
1. 
    @Override    public <T> void put(String key, T value) {
1. 
        put(key,value, Constant.NEVER_EXPIRE);    }
1. 
    @Override    public <T> void put(String key, T value, long expireTime) {
1. 
        if (keySet().size()<maxSize) { // 缓存还有空间
1. 
            saveValue(key,value,expireTime);        } else {                       // 缓存空间不足，需要删除一个
1. 
            if (containsKey(key)) {
1. 
                keys.remove(key);
1. 
                saveValue(key,value,expireTime);            } else {
1. 
                String oldKey = keys.get(0); // 最早缓存的key                evict(oldKey);               // 删除最早缓存的数据 FIFO算法
1. 
                saveValue(key,value,expireTime);            }        }    }
1. 
    private <T> void saveValue(String key, T value, long expireTime) {
1. 
        cache.put(key,value);        timestampMap.put(key,System.currentTimeMillis());        expireTimeMap.put(key,expireTime);        keys.add(key);    }
1. 
    @Override    public Set<String> keySet() {
1. 
        return cache.keySet();    }
1. 
    @Override    public boolean containsKey(String key) {
1. 
        return cache.containsKey(key);    }
1. 
    @Override    public void evict(String key) {
1. 
        cache.remove(key);        timestampMap.remove(key);        expireTimeMap.remove(key);        keys.remove(key);    }
1. 
    @Override    public void evictAll() {
1. 
        cache.clear();        timestampMap.clear();        expireTimeMap.clear();        keys.clear();    }}

到了这里，已经完成了堆外内存在 RxCache 中的封装。其实，已经有很多缓存框架都支持堆外内存，例如 Ehcache、MapDB 等。RxCache 目前已经有了 MapDB 的模块。