人生需要总结

MapDB使用入门

背景

MapDB官网:http://www.mapdb.org

官方翻译之后的话:MapDB基于堆外存储、磁盘存储提供了Java的Maps、Sets、Lists、Queues等功能。它混合了Java集合框架和数据库引擎。它是基于Apache许可的免费的、开源的。

个人觉得:MapDB是一个轻量级的本地缓存的框架,它既可以使用对外存储,也可以使用磁盘存储(重启时数据不丢失)。它还提供事务的功能。

开发文档:https://jankotek.gitbooks.io/mapdb/content/quick-start/

开发机器配置:i5-9400 6c6t,32g内存,固态硬盘

MapDB入门实战

1、引入jar包

<!-- https://mvnrepository.com/artifact/org.mapdb/mapdb -->
<dependency>
    <groupId>org.mapdb</groupId>
    <artifactId>mapdb</artifactId>
    <version>3.0.7</version>
</dependency>

 

2、基于堆外存储的Hello,Simple

    /**
     * 堆外内存map
     */
    public static void offHeapMapTest1() {
        DB db = DBMaker.memoryDB().make();
        ConcurrentMap map = db.hashMap("map").createOrOpen();
        String key = "Hello";
        String val = "simple";
        map.put(key, val);
        System.out.println("第1次取值," + map.get(key));
    }

执行结果:

--Hello,simple----
第1次取值,simple

2.1、插曲

刚开始执行的时候,总是报下面的异常

Exception in thread "main" java.lang.NoClassDefFoundError: org/eclipse/collections/impl/list/mutable/primitive/LongArrayList
    at org.mapdb.StoreDirectAbstract.<init>(StoreDirectAbstract.kt:41)
    at org.mapdb.StoreDirect.<init>(StoreDirect.kt:30)
    at org.mapdb.StoreDirect$Companion.make(StoreDirect.kt:57)
    at org.mapdb.StoreDirect$Companion.make$default(StoreDirect.kt:56)
    at org.mapdb.DBMaker$Maker.make(DBMaker.kt:450)
    at me.lovegao.mapdb.hello.HelloWorldDemo.offHeapMapTest1(HelloWorldDemo.java:18)
    at me.lovegao.mapdb.hello.HelloWorldDemo.main(HelloWorldDemo.java:11)
Caused by: java.lang.ClassNotFoundException: org.eclipse.collections.impl.list.mutable.primitive.LongArrayList
    at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:335)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    ... 7 more

 我以为是jar包没加全,又加了Eclipse相关的jar包,发现还是这样。对着项目又是清理,又是重新编译,又是重新导包,发现都不行。

仔细看了maven的依赖,都是存在的,看MapDB的文档,也说上面那个配置包含全部的。

最后,索性把本地相关的jar包都删了,让maven重新下,最终正常了。

3、基于磁盘的Hello,Simple

基于磁盘存储的,为了保证数据的完整性,需要在关闭虚拟机前关闭DB。

public static void fileMapTest1() {
    DB db = DBMaker.fileDB("file.db").make();
    ConcurrentMap map = db.hashMap("map").createOrOpen();
    String key = "something";
    String val = "here";
    map.put(key, val);
    System.out.println("第1次取值," +map.get(key));
    db.close();
    System.out.println("----------重新打开----------");
    db = DBMaker.fileDB("file.db").make();
    map = db.hashMap("map").createOrOpen();
    System.out.println("第2次取值," +map.get(key));
    db.close();
}

 

执行结果:

--Hello,simple----
第1次取值,simple
----------重新打开----------
第2次取值,simple

结果符合预期。

3.1、基于磁盘的,内存映射的使用

/**
 * 在64位操作系统中,开启内存映射
 * 个性化序列化
 */
public static void fileMapMemoryMapTest() {
    DB db = DBMaker
        .fileDB("file.db")
        .fileMmapEnable()
        .make();
    ConcurrentMap<String,Long> map = db
        .hashMap("mapsl", Serializer.STRING, Serializer.LONG)
        .createOrOpen();
    long val = 51;
    map.put(DEMO_KEY, val);
    System.out.println("第1次取值,期望值:" + val + ",取到的值:" +map.get(DEMO_KEY));
    db.close();
    db = DBMaker
        .fileDB("file.db")
        .fileMmapEnable()
        .make();
     map = db.hashMap("mapsl", Serializer.STRING, Serializer.LONG)
              .createOrOpen();
    System.out.println("第2次取值,期望值:" + val + ",取到的值:" +map.get(DEMO_KEY));
    db.close();
}

 

 执行结果:

--Hello,simple----
第1次取值,期望值:51,取到的值:51
第2次取值,期望值:51,取到的值:51

4、性能对比

1)测试代码

package me.lovegao.mapdb.hello;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentMap;

import org.eclipse.collections.impl.map.mutable.ConcurrentHashMap;
import org.mapdb.DB;
import org.mapdb.DBMaker;
import org.mapdb.Serializer;

public class MapDBSpeedTest {
    private final static String DEMO_KEY = "Hello";
    private final static String DEMO_VAL = "simple";

    public static void main(String[] args) {
        System.out.println("--Hello,simple----");
//        fileMapMemoryMapTest();
        mapTest();
    }
    
    public static void mapTest() {
        int dataNum = 10000;
        List<DB> dbList = new ArrayList();
        Map<String, Map<String, Long>> testMap = new HashMap();
        Map<String, Long> dataMap = generateTestData(dataNum);
        //java原生-堆内map
        ConcurrentMap<String, Long> inHeapDbMap = new ConcurrentHashMap();
        testMap.put("原生map", inHeapDbMap);
        
        
        //堆外map
        DB offHeapDb = DBMaker.memoryDB().make();
        dbList.add(offHeapDb);
        ConcurrentMap offHeapDbMap = offHeapDb.hashMap("map").createOrOpen();
        testMap.put("堆外map", offHeapDbMap);
        
        //基于磁盘map
        DB fileDb = DBMaker.fileDB("file1.db").make();
        dbList.add(fileDb);
        ConcurrentMap<String,Long> fileDbMap = fileDb
                .hashMap("map1", Serializer.STRING, Serializer.LONG)
                .createOrOpen();
        testMap.put("基于磁盘map", fileDbMap);
        
        //基于磁盘-内存映射map
        DB fileMmapDb = DBMaker
                .fileDB("file2.db")
                .fileChannelEnable() //By default MapDB uses RandomAccessFile to access disk storage. Outside fast mmap files there is third option based on FileChannel. It should be faster than RandomAccessFile
                .fileMmapEnable()            // Always enable mmap
//                .fileMmapEnableIfSupported() // Only enable mmap on supported platforms,对性能影响较大
                .fileMmapPreclearDisable()   // Make mmap file faster
//                .allocateStartSize( 10 * 1024*1024*1024)  // 10GB,初始容量
//                .allocateIncrement(512 * 1024*1024)       // 512MB,每次增加容量
                .make();
        //optionally preload file content into disk cache
        fileMmapDb.getStore().fileLoad();
        dbList.add(fileMmapDb);
        ConcurrentMap<String,Long> fileMmapMap = fileMmapDb
                .hashMap("map2", Serializer.STRING, Serializer.LONG)
                .createOrOpen();
        testMap.put("基于磁盘-内存映射map", fileMmapMap);
        
        System.out.println("-----------put---数据量:"+dataNum+"------");
        for(String mapType : testMap.keySet()) {
            putGetMapTest(mapType, testMap.get(mapType), dataMap, true);
        }
        System.out.println("-----------------------------------------\n");
        System.out.println("-----------get---数据量:"+dataNum+"------");
        for(String mapType : testMap.keySet()) {
            putGetMapTest(mapType, testMap.get(mapType), dataMap, false);
        }
        for(DB db : dbList) {
            db.close();
        }
    }
    
    
    /**
     * putGet测试
     * @param map
     * @param dataMap
     * @param put
     * @return <耗时, 异常数>
     */
    public static TwoTuple<Long, Long> putGetMapTest(String mapType, Map<String, Long> map, Map<String, Long> dataMap, boolean put) {
        long useTime = 0L;
        long errorNum = 0L;
        Iterator<Entry<String, Long>> entryIt = dataMap.entrySet().iterator();
        while(entryIt.hasNext()) {
            Entry<String, Long> entry = entryIt.next();
            if(put) {
                long t1 = System.nanoTime();
                map.put(entry.getKey(), entry.getValue());
                useTime = System.nanoTime() - t1;
            } else {
                long t1 = System.nanoTime();
                long val = map.get(entry.getKey());
                useTime = System.nanoTime() - t1;
                if(val != entry.getValue()) {
                    errorNum++;
                }
            }
        }
        double avgUseTime = (double)useTime / dataMap.size();
        String fmtStr = "map类型:%s,总耗时:%dns,平均耗时%ens,异常数量:%d";
        System.out.println(String.format(fmtStr, mapType, useTime, avgUseTime, errorNum));
        return new TwoTuple<Long, Long>(useTime, errorNum);
    }
    
    /**
     * 生成测试数据
     * @param size
     * @return
     */
    public static Map<String, Long> generateTestData(int size) {
        Map<String, Long> map = new HashMap();
        int arrLength = 26;
        char[] words = new char[arrLength];
        for(int i=0; i<arrLength; i++) {
            words[i] = (char) ('a' + i);
        }
        System.out.println(words);
        String demoWord = new String(words);
        for(int i=0; i<size; i++) {
            String key = demoWord.substring(i%arrLength, i%arrLength) + i;
            long val = i;
            map.put(key, val);
        }
        return map;
    }
    
    /**
     * 对外内存map
     */
    public static void offHeapMapTest1() {
        DB db = DBMaker.memoryDB().make();
        ConcurrentMap map = db.hashMap("map").createOrOpen();
        map.put(DEMO_KEY, DEMO_VAL);
        System.out.println("第1次取值," + map.get(DEMO_KEY));
    }
    
    /**
     * 基于磁盘的存储
     */
    public static void fileMapTest1() {
        DB db = DBMaker.fileDB("file.db").make();
        ConcurrentMap map = db.hashMap("map").createOrOpen();
        
        map.put(DEMO_KEY, DEMO_VAL);
        System.out.println("第1次取值," +map.get(DEMO_KEY));
        db.close();
        System.out.println("----------重新打开----------");
        db = DBMaker.fileDB("file.db").make();
        map = db.hashMap("map").createOrOpen();
        System.out.println("第2次取值," +map.get(DEMO_KEY));
        db.close();
    }
    
    /**
     * 在64位操作系统中,开启内存映射
     * 个性化序列化
     */
    public static void fileMapMemoryMapTest() {
        DB db = DBMaker
                .fileDB("file.db")
                .fileMmapEnable()
                .make();
        ConcurrentMap<String,Long> map = db
                .hashMap("mapsl", Serializer.STRING, Serializer.LONG)
                .createOrOpen();
        long val = 51;
        map.put(DEMO_KEY, val);
        System.out.println("第1次取值,期望值:" + val + ",取到的值:" +map.get(DEMO_KEY));
        db.close();
        db = DBMaker
                .fileDB("file.db")
                .fileMmapEnable()
                .make();
         map = db.hashMap("mapsl", Serializer.STRING, Serializer.LONG)
                  .createOrOpen();
        System.out.println("第2次取值,期望值:" + val + ",取到的值:" +map.get(DEMO_KEY));
        db.close();
    }

}

 

 

2)测试结果

map类型 测试数据量 测试类型 总耗时(ns) 平均耗时(ns)
原生map 10000 put 100 1.000000e-02
堆外map 同上 put 4800 4.800000e-01
基于磁盘map 同上 put 345000 3.450000e+01
基于磁盘-内存映射map 同上 put 6000 6.000000e-01
原生map 同上 get 100 1.000000e-02
堆外map 同上 get 2000 2.000000e-01
基于磁盘map 同上 get 75400 7.540000e+00
基于磁盘-内存映射map 同上 get 1100 1.100000e-01

 

 3)结论

①原生的基于堆的map速度始终是最快的

②堆外map和基于磁盘且开启了内存映射的map相比,优势较小。至于原因,有待深入理解。

③对于“基于磁盘-内存映射map”,使用“fileMmapEnableIfSupported”配置,对性能影响较大,建议直接开启。配置“fileMmapPreclearDisable”对于put的性能提升较大(约一倍提升)。

MapDB事务

MapDB是支持事务的,具体使用如下:

package me.lovegao.mapdb.hello;

import java.util.concurrent.ConcurrentMap;

import org.mapdb.DB;
import org.mapdb.DBMaker;
import org.mapdb.Serializer;

public class MapDBTransaction {

    public static void main(String[] args) {
        DB db = DBMaker
                .fileDB("file3.db")
                .fileMmapEnable()
                .transactionEnable()
                .closeOnJvmShutdown() //JVM关闭时关闭db
                .make();
        ConcurrentMap<String,Long> map = db
                .hashMap("mapsl3", Serializer.STRING, Serializer.LONG)
                .createOrOpen();
        map.put("a", 1L);
        map.put("b", 2L);
        db.commit();
        System.out.println(map.get("a"));
        System.out.println(map.get("b"));
        map.put("c", 3L);
        System.out.println("rollback之前,c:" + map.get("c"));
        db.rollback();
        System.out.println("rollback之后,a:" + map.get("a"));
        System.out.println("rollback之后,c:" + map.get("c"));
    }

}

 

运行结果:

1
2
rollback之前,c:3
rollback之后,a:1
rollback之后,c:null

因为配置了closeOnJvmShutdown,所以再次运行时能够正常运行。

如果去掉了transactionEnable和closeOnJvmShutdown,再次运行时将出现以下异常:

Exception in thread "main" org.mapdb.DBException$DataCorruption: Header checksum broken. Store was not closed correctly and might be corrupted. Use `DBMaker.checksumHeaderBypass()` to recover your data. Use clean shutdown or enable transactions to protect the store in the future.
at org.mapdb.StoreDirectAbstract.fileHeaderCheck(StoreDirectAbstract.kt:113)
at org.mapdb.StoreDirect.<init>(StoreDirect.kt:114)
at org.mapdb.StoreDirect$Companion.make(StoreDirect.kt:57)
at org.mapdb.StoreDirect$Companion.make$default(StoreDirect.kt:56)
at org.mapdb.DBMaker$Maker.make(DBMaker.kt:450)
at me.lovegao.mapdb.hello.MapDBTransaction.main(MapDBTransaction.java:17)

最后说以下,fileDB("file3.db")这里的路径可以指定其他目录,默认是在项目的根目录下。

路径是自己创建的,文件是MapDB自动创建的,切记不要多此一举,把文件也创建了,那样会报错的。

 

posted @ 2019-08-31 12:11 水木桶 阅读(...) 评论(...) 编辑 收藏