堆外記憶體及其在 RxCache 中的使用

Tony沈哲發表於2019-01-16

beautiful.jpg

RxCache

RxCache 是一款支援 Java 和 Android 的 Local Cache 。目前,支援堆記憶體、堆外記憶體(off-heap memory)、磁碟快取。

github地址:github.com/fengzhizi71…

堆外記憶體(off-heap memory)

物件可以儲存在 堆記憶體、堆外記憶體、磁碟快取甚至是分散式快取。

在 Java 中,與堆外記憶體相對的是堆記憶體。堆記憶體遵守 JVM 的記憶體管理機制,而堆外記憶體不受到此限制,它由作業系統進行管理。

JVM的記憶體管理以及堆外記憶體.jpg

堆外記憶體和堆記憶體有明顯的區別,或者說有相反的應用場景。

堆外記憶體更適合:

  • 儲存生命週期長的物件
  • 可以在程式間可以共享,減少 JVM 間的物件複製,使得 JVM 的分割部署更容易實現。
  • 本地快取,減少磁碟快取或者分散式快取的響應時間。

RxCache 中使用的堆外記憶體

首先,建立一個 DirectBufferConverter ,用於將物件和 ByteBuffer 相互轉換,以及物件和byte陣列相互轉換。其中,ByteBuffer.allocteDirect(capability) 用於分配堆外記憶體。Cleaner 是自己定義的一個類,用於釋放 DirectByteBuffer。具體程式碼可以檢視:github.com/fengzhizi71…

public abstract class DirectBufferConverter<V> {

    public void dispose(ByteBuffer direct) {

        Cleaner.clean(direct);
    }

    public ByteBuffer to(V from) {
        if(from == null) return null;

        byte[] bytes = toBytes(from);
        ByteBuffer.wrap(bytes);
        ByteBuffer bf = ByteBuffer.allocateDirect(bytes.length);
        bf.put(bytes);
        bf.flip();
        return bf;
    }

    abstract public byte[] toBytes(V value);

    abstract public V toObject(byte[] value);

    public V from(ByteBuffer to) {
        if(to == null) return null;

        byte[] bs = new byte[to.capacity()];
        to.get(bs);
        to.flip();
        return toObject(bs);
    }

}
複製程式碼

接下來,定義一個 ConcurrentDirectHashMap<K, V> 實現Map介面。它是一個範性,支援將 V 轉換成 ByteBuffer 型別,儲存到 ConcurrentDirectHashMap 的 map 中。

public abstract class ConcurrentDirectHashMap<K, V> implements Map<K, V> {

    final private Map<K, ByteBuffer> map;

    private final DirectBufferConverter<V> converter = new DirectBufferConverter<V>() {

        @Override
        public byte[] toBytes(V value) {
            return convertObjectToBytes(value);
        }

        @Override
        public V toObject(byte[] value) {
            return convertBytesToObject(value);
        }
    };

    ConcurrentDirectHashMap() {

        map = new ConcurrentHashMap<>();
    }

    ConcurrentDirectHashMap(Map<K, V> m) {

        map = new ConcurrentHashMap<>();

        for (Entry<K, V> entry : m.entrySet()) {
            K key = entry.getKey();
            ByteBuffer val = converter.to(entry.getValue());
            map.put(key, val);
        }
    }

    protected abstract byte[] convertObjectToBytes(V value);

    protected abstract V convertBytesToObject(byte[] value);

    @Override
    public int size() {
        return map.size();
    }

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

    @Override
    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }

    @Override
    public V get(Object key) {
        final ByteBuffer byteBuffer = map.get(key);
        return converter.from(byteBuffer);
    }

    @Override
    public V put(K key, V value) {
        final ByteBuffer byteBuffer = map.put(key, converter.to(value));
        converter.dispose(byteBuffer);
        return converter.from(byteBuffer);
    }

    @Override
    public V remove(Object key) {
        final ByteBuffer byteBuffer = map.remove(key);
        final V value = converter.from(byteBuffer);
        converter.dispose(byteBuffer);
        return value;
    }

    @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);
        }
    }

    @Override
    public void clear() {
        final Set<K> keys = map.keySet();

        for (K key : keys) {
            map.remove(key);
        }
    }

    @Override
    public Set<K> keySet() {
        return map.keySet();
    }

    @Override
    public Collection<V> values() {
        Collection<V> values = new ArrayList<>();

        for (ByteBuffer byteBuffer : map.values())
        {
            V value = converter.from(byteBuffer);
            values.add(value);
        }
        return values;
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
        Set<Entry<K, V>> entries = new HashSet<>();

        for (Entry<K, ByteBuffer> entry : map.entrySet()) {
            K key = entry.getKey();
            V value = converter.from(entry.getValue());

            entries.add(new Entry<K, V>() {
                @Override
                public K getKey() {
                    return key;
                }

                @Override
                public V getValue() {
                    return value;
                }

                @Override
                public V setValue(V v) {
                    return null;
                }
            });
        }

        return entries;
    }

    @Override
    public boolean containsValue(Object value) {

        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> {

    @Override
    protected byte[] convertObjectToBytes(Object value) {

        return Bytes.serialize(value);
    }

    @Override
    protected Object convertBytesToObject(byte[] value) {

        return Bytes.deserialize(value);
    }
}
複製程式碼

基於 FIFO 以及堆外記憶體來實現 Memory 級別的快取。

public class DirectBufferMemoryImpl extends AbstractMemoryImpl {

    private ConcurrentStringObjectDirectHashMap cache;
    private List<String> keys;

    public DirectBufferMemoryImpl(long maxSize) {

        super(maxSize);
        cache = new ConcurrentStringObjectDirectHashMap();
        this.keys = new LinkedList<>();
    }

    @Override
    public <T> Record<T> getIfPresent(String key) {

        T result = null;

        if(expireTimeMap.get(key)!=null) {

            if (expireTimeMap.get(key)<0) { // 快取的資料從不過期

                result = (T) cache.get(key);
            } else {

                if (timestampMap.get(key) + expireTimeMap.get(key) > System.currentTimeMillis()) {  // 快取的資料還沒有過期

                    result = (T) cache.get(key);
                } else {                     // 快取的資料已經過期

                    evict(key);
                }
            }
        }

        return result != null ? new Record<>(Source.MEMORY,key, result, timestampMap.get(key),expireTimeMap.get(key)) : null;
    }

    @Override
    public <T> void put(String key, T value) {

        put(key,value, Constant.NEVER_EXPIRE);
    }

    @Override
    public <T> void put(String key, T value, long expireTime) {

        if (keySet().size()<maxSize) { // 快取還有空間

            saveValue(key,value,expireTime);
        } else {                       // 快取空間不足,需要刪除一個

            if (containsKey(key)) {

                keys.remove(key);

                saveValue(key,value,expireTime);
            } else {

                String oldKey = keys.get(0); // 最早快取的key
                evict(oldKey);               // 刪除最早快取的資料 FIFO演算法

                saveValue(key,value,expireTime);
            }
        }
    }

    private <T> void saveValue(String key, T value, long expireTime) {

        cache.put(key,value);
        timestampMap.put(key,System.currentTimeMillis());
        expireTimeMap.put(key,expireTime);
        keys.add(key);
    }

    @Override
    public Set<String> keySet() {

        return cache.keySet();
    }

    @Override
    public boolean containsKey(String key) {

        return cache.containsKey(key);
    }

    @Override
    public void evict(String key) {

        cache.remove(key);
        timestampMap.remove(key);
        expireTimeMap.remove(key);
        keys.remove(key);
    }

    @Override
    public void evictAll() {

        cache.clear();
        timestampMap.clear();
        expireTimeMap.clear();
        keys.clear();
    }
}
複製程式碼

到了這裡,已經完成了堆外記憶體在 RxCache 中的封裝。其實,已經有很多快取框架都支援堆外記憶體,例如 Ehcache、MapDB 等。RxCache 目前已經有了 MapDB 的模組。

總結

RxCache 是一款 Local Cache,它已經應用到我們專案中,也在我個人的爬蟲框架 NetDiscovery 中使用。未來,它會作為一個成熟的元件,不斷運用到公司和個人的其他專案中。

RxCache 系列的相關文章:

  1. ReentrantReadWriteLock讀寫鎖及其在 RxCache 中的使用
  2. Retrofit 風格的 RxCache及其多種快取替換演算法
  3. RxCache 整合 Android 的持久層框架 greenDAO、Room
  4. 給 Java 和 Android 構建一個簡單的響應式Local Cache

Java與Android技術棧:每週更新推送原創技術文章,歡迎掃描下方的公眾號二維碼並關注,期待與您的共同成長和進步。

堆外記憶體及其在 RxCache 中的使用

相關文章