[关闭]
@aloxc 2017-12-05T06:20:59.000000Z 字数 16436 阅读 914

ignite的cache性能测试

ignite cache

如题，这段时间在研究ignite，看样子ignite还是挺好的一东西，但是做这几天做了cache功能的性能测试，发现一些问题，
1、嵌入式（clientMode=false,且只在java中使用start方法内嵌启动ignite）性能还行吧
2、本地模式（clientMode=true,且在测试机器上独立的启动一个ignite服务，windows执行bin/ignite.bat,linux执行bin/ignite.sh，并且在此测试机器上运行性能测试的java代码）性能差很多。
3、集群模式（clientMode=true,独立在两台机器上启动ignite服务，在第三台机器上运行性能测试代码）性能一样的差。

这些测试对应的其它配置为
1. 缓存配置：关闭备注backups=0
2. 缓存配置：不限制堆外内存大小OffHeapMaxMemory=0
3. 缓存配置：初始化缓存容量大小 StartSize = 300 * 1024 *1024
4. 缓存配置：禁用交换存储空间swapEnabled=false
5. 部署模式设置为DeploymentMode=SHARED
6. 对等类加载PeerClassLoadingEnabled=true

每次每项测试完毕后清空缓存，每项做20次测试后取平均值，测试数据量分别为5000，10000,20000,50000,100000，测试线程分别为1线程，10线程，20线程，50线程，100线程，200线程。测试方法为总数据量除以线程数就是每线程需要测试的数据量，测试开始时间为startTime,每项操作的所有线程执行完毕的时间为endTime，spendTime=endTime-startTime,所有20次测试的spendTime相加后除以20,得到平均操作时间avgSpendTime，再用总数据量除以avgSpendTime得出每秒能执行的次数。

经过几论测试下来，得到下面这些数据，从数据看出，ignite的cache功能根本无法用于线上服务（嵌入式基本上没什么用），无法做OLTP的补充。

本地windows机器配置：
intel 奔腾 G2030，win7 64bit，8GB ram，180G intel 320 ssd with sata2，
linux机器配置(3台)：
intel 至强 E5606，centos release 6.2 final 64bit 2.6.32内核，4GB ram，xxG sas，

以下测试结果的数字是指每秒能执行的次数，

1.本地嵌入式模式（windows7下面，不启动独立服务，设置clientMode=false）

本地嵌入式
config.txt

  1. thread_count=1,10,20,50,100,200
  2. data_count=5000,10000,20000,50000,100000
  3. show_log=false
  4. test_count=20
  5. client_mode=0
  6. is_avg_time=false
  7. spi_windows=127.0.0.1:47500..47509
  8. spi_linux=172.31.16.68:47500..47509,172.31.16.69:47500..47509

2.本地模式（windows7下面，启动一个独立的ignite服务并在当前机器上启动测试代码）

本地
config.txt

  1. thread_count=1,10,20,50,100,200
  2. data_count=5000,10000,20000,50000,100000
  3. show_log=false
  4. test_count=20
  5. client_mode=1
  6. is_avg_time=false
  7. spi_windows=127.0.0.1:47500..47509
  8. spi_linux=172.31.16.68:47500..47509,172.31.16.69:47500..47509

3.linux嵌入式模式（linux下，不启动独立服务，设置clientMode=false）

linux嵌入式
config.txt

  1. thread_count=1,10,20,50,100,200
  2. data_count=5000,10000,20000,50000,100000
  3. show_log=false
  4. test_count=20
  5. client_mode=0
  6. is_avg_time=false
  7. spi_windows=127.0.0.1:47500..47509
  8. spi_linux=172.31.16.68:47500..47509,172.31.16.69:47500..47509

4.linux本地模式（linux下，启动一个独立的ignite服务并在当前机器上启动测试代码）

linux本地
config.txt

  1. thread_count=1,10,20,50,100,200
  2. data_count=5000,10000,20000,50000,100000
  3. show_log=false
  4. test_count=20
  5. client_mode=1
  6. is_avg_time=false
  7. spi_windows=127.0.0.1:47500..47509
  8. spi_linux=172.31.16.68:47500..47509,172.31.16.69:47500..47509

5.linux集群2服务节点模式（linux下，分别在两台linux服务器上启动一个独立的ignite服务，在第三台上启动测试代码）

linux集群2服务节点
config.txt

  1. thread_count=1,10,20,50,100,200
  2. data_count=5000,10000,20000,50000,100000
  3. show_log=false
  4. test_count=20
  5. client_mode=2
  6. is_avg_time=false
  7. spi_windows=127.0.0.1:47500..47509
  8. spi_linux=172.31.16.68:47500..47509,172.31.16.69:47500..47509

6.linux集群1服务节点模式（linux下，在一台linux服务器上启动一个独立的ignite服务，在第二台上启动测试代码）

linux集群1服务节点
config.txt

  1. thread_count=1,10,20,50,100,200
  2. data_count=5000,10000,20000,50000,100000
  3. show_log=false
  4. test_count=20
  5. client_mode=2
  6. is_avg_time=false
  7. spi_windows=127.0.0.1:47500..47509
  8. spi_linux=172.31.16.68:47500..47509

补充下：测试的缓存类型key为Integer，value为下面这个bean的实例。每次操作的key和value都不一样，下面是所有测试代码，
IgniteBenchmark2.java

  1. package com.github.aloxc.ignite.benchmark;
  3. import org.apache.commons.logging.Log;
  4. import org.apache.commons.logging.LogFactory;
  5. import org.apache.ignite.Ignite;
  6. import org.apache.ignite.IgniteCache;
  7. import org.apache.ignite.Ignition;
  8. import org.apache.ignite.cache.CacheMode;
  9. import org.apache.ignite.configuration.CacheConfiguration;
  10. import org.apache.ignite.configuration.DeploymentMode;
  11. import org.apache.ignite.configuration.IgniteConfiguration;
  12. import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi;
  13. import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;
  14. import org.apache.poi.hssf.usermodel.*;
  15. import org.apache.poi.ss.usermodel.CellStyle;
  16. import org.apache.poi.ss.usermodel.IndexedColors;
  18. import java.io.File;
  19. import java.io.FileInputStream;
  20. import java.io.FileOutputStream;
  21. import java.sql.Timestamp;
  22. import java.util.*;
  23. import java.util.concurrent.CountDownLatch;
  25. /**
  26.  * Created by Administrator on 2016/12/9.
  27.  */
  28. public class IgniteBenchmark2 {
  29.     private static Log logger = LogFactory.getLog(IgniteBenchmark2.class);
  30.     //测试的数据行数
  31.     private static int[] DATA_COUNT_ARRAY;
  32.     private static int[] THREAD_COUNT_ARRAY;
  33.     private static boolean isWindows = false;
  34.     private static final String CACHE_NAME = "benchmark2";
  35.     private static Ignite IGNITE;
  36.     private static IgniteCache<Integer, BenchmarkUser> CACHE;
  37.     private Map<Integer, Set<Integer>> keyMap = null;
  38.     private Map<Integer, Map<Integer, BenchmarkUser>> valueMap = null;
  39.     private static int TEST_COUNT = 0;
  40.     private static int CLIENT_MODE = 0;//0:嵌入式，1：本地，2，集群
  41.     private static boolean IS_AVG_TIME = false;
  42.     private static List<String> IP_LIST = null;
  43.     private static String outPath;
  46.     private static boolean SHOW_LOG = false;
  48.     static {
  49.         Properties props = System.getProperties(); //获得系统属性集
  50.         String osName = props.getProperty("os.name"); //操作系统名称
  51.         if (osName.toLowerCase().contains("windows")) {
  52.             isWindows = true;
  53.         }
  54.     }
  56.     public static void main(String[] args) {
  57.         logger.error("开始测试benchmark2");
  58.         try {
  60.             File file;
  61.             if (isWindows) {
  62.                 file = new File("D:\\ideaprojects\\ignite-examples\\config\\config.txt");
  63.                 outPath = "D:/log/ignite-benchmark-windows";
  64.             } else {
  65.                 file = new File("/usr/java/ignitebenchmark/config.txt");
  66.                 outPath = "/usr/java/ignitebenchmark/ignite-benchmark-linux";
  67.             }
  68.             if (!file.exists()) {
  69.                 logger.error("config文件不存在，退出程序 " + file.getAbsolutePath());
  70.                 System.exit(1);
  71.             } else {
  72.                 Properties properties = new Properties();
  73.                 properties.load(new FileInputStream(file));
  74.                 String[] infos = properties.getProperty("data_count").split(",");
  75.                 DATA_COUNT_ARRAY = new int[infos.length];
  76.                 for (int i = 0; i < infos.length; i++) {
  77.                     DATA_COUNT_ARRAY[i] = Integer.parseInt(infos[i]);
  78.                 }
  79.                 CLIENT_MODE = Integer.parseInt(properties.getProperty("client_mode"));
  80.                 infos = properties.getProperty("thread_count").split(",");
  81.                 THREAD_COUNT_ARRAY = new int[infos.length];
  82.                 for (int i = 0; i < infos.length; i++) {
  83.                     THREAD_COUNT_ARRAY[i] = Integer.parseInt(infos[i]);
  84.                 }
  85.                 IgniteConfiguration cfg = new IgniteConfiguration();
  86.                 if(CLIENT_MODE == 0 ) {
  87.                     cfg.setClientMode(false);
  88.                     outPath += "-嵌入式";
  89.                 }else{
  90.                     cfg.setClientMode(true);
  91.                     TcpDiscoverySpi spi = new TcpDiscoverySpi();
  92.                     TcpDiscoveryVmIpFinder ipFinder = new TcpDiscoveryVmIpFinder();
  93.                     if(CLIENT_MODE == 1){
  94.                         ipFinder.setAddresses(Arrays.asList("127.0.0.1:47500..47509".split(",")));
  95.                         outPath += "-本地";
  96.                     }else if(CLIENT_MODE == 2){
  97.                         outPath += "-集群";
  98.                         if (isWindows) {
  99.                             ipFinder.setAddresses(Arrays.asList(properties.getProperty("spi_windows").split(",")));
  100.                         } else {
  101.                             ipFinder.setAddresses(Arrays.asList(properties.getProperty("spi_linux").split(",")));
  102.                         }
  103.                     }
  104.                     spi.setIpFinder(ipFinder);
  105.                     cfg.setDiscoverySpi(spi);
  106.                 }
  108.                 CacheConfiguration cacheConfiguration = new CacheConfiguration<String, DataClass>();
  109.                 cacheConfiguration.setCacheMode(CacheMode.PARTITIONED);//分区
  110.                 cacheConfiguration.setBackups(0);//关闭备份
  111.                 //cacheConfiguration.setOffHeapMaxMemory(0);//不限制堆外内存大小
  112.                 cacheConfiguration.setStartSize(3 * 1024 *1024);//初始化缓存容量大小，类似于hashmap的size
  113.                 cacheConfiguration.setSwapEnabled(false);//禁用交换存储
  114.                 cfg.setCacheConfiguration(cacheConfiguration);
  115.                 cfg.setDeploymentMode(DeploymentMode.SHARED);
  116.                 cfg.setPeerClassLoadingEnabled(true);
  118.                 TEST_COUNT = Integer.parseInt(properties.getProperty("test_count"));
  119.                 SHOW_LOG = Boolean.parseBoolean(properties.getProperty("show_log"));
  120.                 IS_AVG_TIME = Boolean.parseBoolean(properties.getProperty("is_avg_time"));
  121.                 if(IS_AVG_TIME){
  122.                     outPath += "-取平均时间";
  123.                 }else{
  124.                     outPath += "-取总时间";
  125.                 }
  126.                 outPath += ".xls";
  127.                 IGNITE = Ignition.start(cfg);
  128.                 CACHE = IGNITE.getOrCreateCache(CACHE_NAME);
  129.             }
  130.             logger.error("资源初始化完毕" + CLIENT_MODE);
  131.             new IgniteBenchmark2().test();
  133.         } catch (Exception e) {
  134.             e.printStackTrace();
  135.         } finally {
  136.             logger.error("程序运行完毕，删除缓存");
  137.             IGNITE.destroyCache(CACHE_NAME);
  138.             System.exit(1);
  139.         }
  140.     }
  142.     private void test() throws Exception {
  143.         HSSFWorkbook wb = new HSSFWorkbook();
  144.         HSSFSheet sheet = wb.createSheet();
  145.         HSSFRow row = null;
  146.         HSSFCell cell = null;
  147.         int rowIndex = 0;
  148.         int cellIndex = 0;
  149.         HSSFCellStyle threadActionStyle = wb.createCellStyle();
  150.         threadActionStyle.setFillForegroundColor(IndexedColors.LIGHT_CORNFLOWER_BLUE.getIndex());
  151.         threadActionStyle.setFillPattern(CellStyle.SOLID_FOREGROUND);
  153.         HSSFCellStyle dataCountStyle = wb.createCellStyle();
  154.         dataCountStyle.setFillForegroundColor(IndexedColors.LIGHT_ORANGE.getIndex());
  155.         dataCountStyle.setFillPattern(CellStyle.SOLID_FOREGROUND);
  156.         for (int dataIndex = 0; dataIndex < DATA_COUNT_ARRAY.length; dataIndex++) {
  157.             int cellI = 0;
  158.             int dataCount = DATA_COUNT_ARRAY[dataIndex];
  159.             row = sheet.createRow(rowIndex++);//数据量和线程行
  160.             cell = row.createCell(0);
  161.             cell.setCellValue("总数据量" + dataCount);
  162.             cell.setCellStyle(dataCountStyle);
  164.             cellIndex = 0;
  165.             for (int threadIndex = 0; threadIndex < THREAD_COUNT_ARRAY.length; threadIndex++) {
  166.                 int threadCount = THREAD_COUNT_ARRAY[threadIndex];
  167.                 cellIndex++;
  168.                 cell = row.createCell(cellIndex);
  169.                 cell.setCellValue(threadCount + "线程");
  170.                 cell.setCellStyle(threadActionStyle);
  171.             }
  173.             row = sheet.createRow(rowIndex++);//写入行
  174.             cell = row.createCell(0);
  175.             cell.setCellValue("写入");
  176.             cell.setCellStyle(threadActionStyle);
  178.             row = sheet.createRow(rowIndex++);//读取行
  179.             cell = row.createCell(0);
  180.             cell.setCellValue("读取");
  181.             cell.setCellStyle(threadActionStyle);
  183.             row = sheet.createRow(rowIndex++);//批量写入行
  184.             cell = row.createCell(0);
  185.             cell.setCellValue("批量写入");
  186.             cell.setCellStyle(threadActionStyle);
  188.             row = sheet.createRow(rowIndex++);//批量读取行
  189.             cell = row.createCell(0);
  190.             cell.setCellValue("批量读取");
  191.             cell.setCellStyle(threadActionStyle);
  193.             rowIndex++;
  194.         }
  195.         for (int i = 0; i < THREAD_COUNT_ARRAY.length + 1; i++) {
  196.             sheet.setColumnWidth(i, 256 * 15);
  197.         }
  198.         int preThreadCount = 1;
  199.         int preDataCount = 50000;
  200.         keyMap = new HashMap<>(preThreadCount);
  201.         valueMap = new HashMap<>(preThreadCount);
  202.         genObject(preThreadCount, preDataCount);
  204.         new WriteThread(0, null, false, valueMap.get(0),"测试写").run();
  205.         new ReadThread(0, null, false, keyMap.get(0),"测试读").run();
  207.         Thread.sleep(5000);
  209.         for (int dataIndex = 0; dataIndex < DATA_COUNT_ARRAY.length; dataIndex++) {
  210.             int dataCount = DATA_COUNT_ARRAY[dataIndex];
  211.             final int baseRowIndex = dataIndex * 6;//
  212.             for (int threadIndex = 0; threadIndex < THREAD_COUNT_ARRAY.length; threadIndex++) {
  213.                 int threadCount = THREAD_COUNT_ARRAY[threadIndex];
  214.                 keyMap = new HashMap<>(threadCount);
  215.                 valueMap = new HashMap<>(threadCount);
  216.                 genObject(threadCount, dataCount);
  217.                 logger.error("开始benchmark测试,threadCount=" + threadCount + "\tdataCount=" + dataCount);
  219.                 float[] spends = new float[4];
  220.                 for (int ti = 0; ti < TEST_COUNT; ti++) {
  222.                     CACHE.removeAll();
  223.                     float avgSpend = 0f;
  224.                     WriteThread[] writeThreads = new WriteThread[threadCount];
  225.                     CountDownLatch latch = new CountDownLatch(threadCount);
  226.                     float interval;
  227.                     float tpms;
  228.                     long start = System.currentTimeMillis();
  229.                     for (int i = 0; i < writeThreads.length; i++) {
  230.                         writeThreads[i] = new WriteThread(i, latch, false, valueMap.get(i),"[写线程-" + i + "]");
  231.                         writeThreads[i].start();
  232.                     }
  233.                     latch.await();
  234.                     long end = System.currentTimeMillis();
  235.                     if (IS_AVG_TIME) {
  236.                         avgSpend = 0f;
  237.                         for (int i = 0; i < writeThreads.length; i++) {
  238.                             avgSpend += writeThreads[i].getSpend();
  239.                         }
  240.                         avgSpend = avgSpend / writeThreads.length;
  241.                         spends[0] += avgSpend;
  242.                     } else {
  243.                         spends[0] += end - start;
  244.                     }
  245.                     Thread.sleep(50);
  247.                     ReadThread[] readThreads = new ReadThread[threadCount];
  248.                     latch = new CountDownLatch(threadCount);
  249.                     start = System.currentTimeMillis();
  250.                     for (int i = 0; i < readThreads.length; i++) {
  251.                         readThreads[i] = new ReadThread(i, latch, false, keyMap.get(i),"[读线程-" + i + "]");
  252.                         readThreads[i].start();
  253.                     }
  254.                     latch.await();
  255.                     end = System.currentTimeMillis();
  256.                     if (IS_AVG_TIME) {
  257.                         avgSpend = 0f;
  258.                         for (int i = 0; i < readThreads.length; i++) {
  259.                             avgSpend += readThreads[i].getSpend();
  260.                         }
  261.                         avgSpend = avgSpend / writeThreads.length;
  262.                         spends[1] += avgSpend;
  263.                     } else {
  264.                         spends[1] += end - start;
  265.                     }
  266.                     CACHE.removeAll();
  267.                     Thread.sleep(50);
  270.                     latch = new CountDownLatch(threadCount);
  271.                     start = System.currentTimeMillis();
  272.                     for (int i = 0; i < writeThreads.length; i++) {
  273.                         writeThreads[i] = new WriteThread(i, latch, true, valueMap.get(i),"[批量写线程-" + i + "]");
  274.                         writeThreads[i].start();
  275.                     }
  276.                     latch.await();
  277.                     end = System.currentTimeMillis();
  278.                     if (IS_AVG_TIME) {
  279.                         avgSpend = 0f;
  280.                         for (int i = 0; i < writeThreads.length; i++) {
  281.                             avgSpend += writeThreads[i].getSpend();
  282.                         }
  283.                         avgSpend = avgSpend / writeThreads.length;
  284.                         spends[2] += avgSpend;
  285.                     } else {
  286.                         spends[2] += end - start;
  287.                     }
  288.                     Thread.sleep(50);
  291.                     latch = new CountDownLatch(threadCount);
  292.                     start = System.currentTimeMillis();
  293.                     for (int i = 0; i < readThreads.length; i++) {
  294.                         readThreads[i] = new ReadThread(i, latch, true, keyMap.get(i),"[批量读线程-" + i + "]");
  295.                         readThreads[i].start();
  296.                     }
  297.                     latch.await();
  298.                     end = System.currentTimeMillis();
  299.                     if (IS_AVG_TIME) {
  300.                         avgSpend = 0f;
  301.                         for (int i = 0; i < readThreads.length; i++) {
  302.                             avgSpend += readThreads[i].getSpend();
  303.                         }
  304.                         avgSpend = avgSpend / writeThreads.length;
  305.                         spends[3] += avgSpend;
  306.                     } else {
  307.                         spends[3] += end - start;
  308.                     }
  310.                 }
  311.                 rowIndex = baseRowIndex + 1;
  312.                 cellIndex = threadIndex + 1;
  314.                 for (int i = 0; i < spends.length; i++) {
  315.                     row = sheet.getRow(rowIndex++);
  316.                     cell = row.createCell(cellIndex);
  317.                     float avgSpend = spends[i] / 1000L;
  318.                     avgSpend /= TEST_COUNT;
  319.                     cell.setCellValue(Math.ceil(dataCount / avgSpend));
  320.                 }
  321.             }
  322.         }
  324.         logger.error("测试完毕，准备输出测试结果到[" + outPath + "]");
  325.         FileOutputStream out = new FileOutputStream(outPath);
  326.         wb.write(out);
  327.         out.close();
  328.     }
  330.     /**
  331.      * 产生测试数据
  332.      */
  333.     private void genObject(int threadCount, int dataCount) {
  334.         long start = System.currentTimeMillis();
  335.         Random r = new Random();
  336.         int perCount = dataCount / threadCount;
  337.         for (int i = 0; i < threadCount; i++) {
  338.             Map<Integer, BenchmarkUser> map = new HashMap<>(dataCount);
  339.             Set<Integer> keyset = new HashSet<>(dataCount);
  340.             int id = 0;
  341.             for (int j = 0; j < perCount; j++) {
  342.                 BenchmarkUser user = new BenchmarkUser();
  343.                 id = i * perCount + j;
  344.                 user.setId(id);
  345.                 user.setName("user-" + id);
  346.                 user.setCommentCount(id);
  347.                 user.setComposeCount(id);
  348.                 user.setReplyCount(id);
  349.                 user.setIp("ip" + id);
  350.                 user.setLoginCount(id);
  351.                 user.setPermission(r.nextBoolean());
  352.                 user.setLoginTime(new Timestamp(System.currentTimeMillis()));
  353.                 user.setRegisterTime(new Timestamp(System.currentTimeMillis()));
  355.                 map.put(id, user);
  356.                 keyset.add(id);
  357.             }
  358.             keyMap.put(i, keyset);
  359.             valueMap.put(i, map);
  360.         }
  361. //        logger.error("生成测试数据花费" + (System.currentTimeMillis() - start) + "毫秒,线程数 = " + threadCount + ",每线程数据量 = " + (dataCount / threadCount));
  362.     }
  364.     static class ReadThread extends Thread {
  365.         private final int index;
  366.         private final CountDownLatch latch;
  367.         private Set<Integer> keySet;
  368.         private final boolean bBatch;
  369.         private long spend = 0;
  371.         public ReadThread(int index, CountDownLatch latch, boolean bBatch, Set<Integer> keySet,String threadName) {
  372.             super(threadName);
  373.             this.index = index;
  374.             this.latch = latch;
  375.             this.keySet = keySet;
  376.             this.bBatch = false;
  377.         }
  379.         public long getSpend() {
  380.             return spend;
  381.         }
  383.         @Override
  384.         public void run() {
  385.             long start = System.currentTimeMillis();
  386.             if (bBatch) {
  387.                 CACHE.getAll(keySet);
  388.             } else {
  389.                 long spend1 = System.currentTimeMillis();
  390.                 for (Integer key : keySet) {
  391.                     CACHE.get(key);
  392.                 }
  393. //                logger.error("读取线程[" + index + "]花费" + (keySet.size() / (System.currentTimeMillis() - spend1)) + "毫秒");
  394.             }
  395.             spend = System.currentTimeMillis() - start;
  396.             if (SHOW_LOG) {
  397.                 logger.error(this.getName() + "花费" + (spend) + "毫秒");
  398.             }
  399.             if (latch != null) {
  400.                 latch.countDown();
  401.             }
  402.         }
  403.     }
  405.     static class WriteThread extends Thread {
  406.         private final int index;
  407.         private final CountDownLatch latch;
  408.         private final boolean bBatch;
  409.         private Map<Integer, BenchmarkUser> valueMap;
  410.         private long spend = 0;
  413.         public WriteThread(int index, CountDownLatch latch, boolean bBatch, Map<Integer, BenchmarkUser> valueMap,String threadName) {
  414.             super(threadName);
  415.             this.index = index;
  416.             this.latch = latch;
  417.             this.bBatch = bBatch;
  418.             this.valueMap = valueMap;
  419.         }
  421.         public long getSpend() {
  422.             return spend;
  423.         }
  425.         @Override
  426.         public void run() {
  427.             long start = System.currentTimeMillis();
  428.             if (bBatch) {
  429.                 CACHE.putAll(valueMap);
  430.             } else {
  431.                 long spend1 = System.currentTimeMillis();
  432.                 for (Map.Entry<Integer, BenchmarkUser> entry : valueMap.entrySet()) {
  433.                     CACHE.put(entry.getKey(), entry.getValue());
  434.                 }
  435. //                logger.error("写入线程[" + index + "]花费" + (valueMap.size() / (System.currentTimeMillis() - spend1)) + "毫秒");
  436.             }
  437.             spend = System.currentTimeMillis() - start;
  438.             if (SHOW_LOG) {
  439.                 logger.error(this.getName() + "花费" + spend + "毫秒");
  440.             }
  441.             if (latch != null) {
  442.                 latch.countDown();
  443.             }
  444.         }
  445.     }
  447. }

BenchmarkUser.java

  1. package com.github.aloxc.ignite.benchmark;
  3. import com.github.aloxc.fw.util.JsonUtil;
  5. import java.io.Serializable;
  6. import java.sql.Timestamp;
  8. /**
  9.  * Created by Administrator on 2016/12/15.
  10.  */
  11. public class  BenchmarkUser implements Serializable{
  12.     private int id;         // 自增长ID[回复ID]
  13.     private String name;        // 用户名
  14.     private String ip;          // 用户IP
  15.     private int loginCount;     // 登录次数
  16.     private int composeCount;   // 发表主题数
  17.     private int replyCount;     // 回复数
  18.     private int commentCount;  // 评论数
  19.     private boolean permission; // [没有注销=true][已被注销=false]
  20.     private Timestamp loginTime;    // 最新上站时间
  21.     private Timestamp registerTime; // 注册时间
  24.     @Override
  25.     public int hashCode() {
  26.         final int prime = 31;
  27.         int result = 1;
  28.         result = prime * result + id;
  29.         return result;
  30.     }
  32.     @Override
  33.     public boolean equals(Object obj) {
  34.         if (this == obj)
  35.             return true;
  36.         if (obj == null)
  37.             return false;
  38.         if (getClass() != obj.getClass())
  39.             return false;
  40.         BenchmarkUser other = (BenchmarkUser) obj;
  41.         if (id != other.id)
  42.             return false;
  43.         return true;
  44.     }
  46.     @Override
  47.     public String toString() {
  48.         return JsonUtil.toJson(this);
  49.     }
  51.     public int getId() {
  52.         return id;
  53.     }
  55.     public void setId(int id) {
  56.         this.id = id;
  57.     }
  59.     public String getName() {
  60.         return name;
  61.     }
  63.     public void setName(String name) {
  64.         this.name = name;
  65.     }
  67.     public String getIp() {
  68.         return ip;
  69.     }
  71.     public void setIp(String ip) {
  72.         this.ip = ip;
  73.     }
  75.     public int getLoginCount() {
  76.         return loginCount;
  77.     }
  79.     public void setLoginCount(int loginCount) {
  80.         this.loginCount = loginCount;
  81.     }
  83.     public int getComposeCount() {
  84.         return composeCount;
  85.     }
  87.     public void setComposeCount(int composeCount) {
  88.         this.composeCount = composeCount;
  89.     }
  91.     public int getReplyCount() {
  92.         return replyCount;
  93.     }
  95.     public void setReplyCount(int replyCount) {
  96.         this.replyCount = replyCount;
  97.     }
  99.     public int getCommentCount() {
  100.         return commentCount;
  101.     }
  103.     public void setCommentCount(int commentCount) {
  104.         this.commentCount = commentCount;
  105.     }
  107.     public boolean isPermission() {
  108.         return permission;
  109.     }
  111.     public void setPermission(boolean permission) {
  112.         this.permission = permission;
  113.     }
  115.     public Timestamp getLoginTime() {
  116.         return loginTime;
  117.     }
  119.     public void setLoginTime(Timestamp loginTime) {
  120.         this.loginTime = loginTime;
  121.     }
  123.     public Timestamp getRegisterTime() {
  124.         return registerTime;
  125.     }
  127.     public void setRegisterTime(Timestamp registerTime) {
  128.         this.registerTime = registerTime;
  129.     }
  130. }

x

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注