Java 尝试测量插入在数据库中花费的时间

我有一个

多线程程序

，它将插入到我的一个表中，我正在这样运行该程序-

java-jar CannedTest.jar 100 10000

这意味着：

• 线程数为

  100

• 任务数为

  10000

因此，每个线程将在我的表中插入

10000条记录。这意味着在程序完成执行后，表中的
总计数（100*10000）
应该是
1000000

作为LnP测试的一部分，我试图测量一个insert在我的表中占用的时间。我将所有这些数字存储在一个
ConcurrentHashMap
中，就像插入数据库所花费的时间，如下所示

long start = System.nanoTime();

callableStatement[pos].executeUpdate(); // flush the records.

long end = System.nanoTime() - start;

final AtomicLong before = insertHistogram.putIfAbsent(end / 1000000L, new AtomicLong(1L));
if (before != null) {
    before.incrementAndGet();
}

17:46:06,112  INFO LoadTest:195 - Insert Histogram List:
17:46:06,112  INFO LoadTest:212 - 64823 came back between 1 and 2 ms
17:46:06,112  INFO LoadTest:212 - 115253 came back between 3 and 4 ms
17:46:06,112  INFO LoadTest:212 - 447846 came back between 5 and 8 ms
17:46:06,112  INFO LoadTest:212 - 330533 came back between 9 and 16 ms
17:46:06,112  INFO LoadTest:212 - 29188 came back between 17 and 32 ms
17:46:06,112  INFO LoadTest:212 - 6548 came back between 33 and 64 ms
17:46:06,112  INFO LoadTest:212 - 3821 came back between 65 and 128 ms
17:46:06,113  INFO LoadTest:212 - 1988 came back greater than 128 ms

当所有线程都执行完所有任务后，我尝试通过在
键上对
进行排序，将
ConcurrentHashMap insertHistogram
中的数字打印出来，即
毫秒
，结果如下所示-

Milliseconds           Number
0                      2335
1                      62488
2                      60286
3                      54967
4                      52374
5                      93034
6                      123083
7                      179355
8                      118686
9                      87126
10                     42305
..                      ..
..                      ..
..                      ..

另外，从相同的
ConcurrentHashMap插入直方图中，我尝试制作一个如下所示的直方图

long start = System.nanoTime();

callableStatement[pos].executeUpdate(); // flush the records.

long end = System.nanoTime() - start;

final AtomicLong before = insertHistogram.putIfAbsent(end / 1000000L, new AtomicLong(1L));
if (before != null) {
    before.incrementAndGet();
}

17:46:06,112  INFO LoadTest:195 - Insert Histogram List:
17:46:06,112  INFO LoadTest:212 - 64823 came back between 1 and 2 ms
17:46:06,112  INFO LoadTest:212 - 115253 came back between 3 and 4 ms
17:46:06,112  INFO LoadTest:212 - 447846 came back between 5 and 8 ms
17:46:06,112  INFO LoadTest:212 - 330533 came back between 9 and 16 ms
17:46:06,112  INFO LoadTest:212 - 29188 came back between 17 and 32 ms
17:46:06,112  INFO LoadTest:212 - 6548 came back between 33 and 64 ms
17:46:06,112  INFO LoadTest:212 - 3821 came back between 65 and 128 ms
17:46:06,113  INFO LoadTest:212 - 1988 came back greater than 128 ms

注意：-我试图在其中插入记录的数据库，当前处于
内存模式

问题陈述：-

看看我上面的结果中的这个数字，它通过在键上排序打印出来-

02335

我不确定在
0毫秒内插入了
2335个调用
的可能性？我还在测量插入时使用
System.nanotime

下面是打印上述日志的代码-

private static void logHistogramInfo() {

    int[] definition = { 0, 2, 4, 8, 16, 32, 64, 128 };
    long[] buckets = new long[definition.length];

    System.out.println("Milliseconds           Number");
    SortedSet<Long> keys = new TreeSet<Long>(Task.insertHistogram.keySet());
    for (long key : keys) { 
       AtomicLong value = Task.insertHistogram.get(key);
       System.out.println(key+ "                      " + value);
    }

    LOG.info("Insert Histogram List: ");
    for (Long time : Task.insertHistogram.keySet()) {
        for (int i = definition.length - 1; i >= 0; i--) {
            if (time >= definition[i]) {
                buckets[i] += Task.insertHistogram.get(time).get();
                break;
            }
        }
    }
    for (int i = 0; i < definition.length; i++) {
        String period = "";
        if (i == definition.length - 1) {
            period = "greater than " + definition[i] + " ms";
        } else {
            period = "between " + (definition[i] + 1) + " and " + definition[i + 1] + " ms";
        }
        LOG.info(buckets[i] + " came back " + period);
    }

}

private static void loghistorograminfo（）{
int[]定义={0,2,4,8,16,32,64,128}；
long[]bucket=新的long[definition.length]；
System.out.println（“毫秒数”）；
SortedSet keys=新树集（Task.insertHistogram.keySet（））；
对于（长键：键）{
AtomicLong值=Task.insertHistogram.get（键）；
System.out.println（键+“”+值）；
}
LOG.info（“插入直方图列表：”）；
for（长时间：Task.insertHistogram.keySet（））{
对于（int i=definition.length-1；i>=0；i--）{
如果（时间>=定义[i]）{
bucket[i]+=Task.insertHistogram.get（time.get（）；
打破
}
}
}
for（int i=0；i

我不确定当我试图通过在键上排序直接打印地图中的值时，为什么会显示
0
毫秒

但是，当我尝试使用相同的
logHistogramInfo方法制作直方图时，没有显示相同的
0毫秒

在上述方法的计算过程中，我是否有任何错误？
“因此每个线程将在我的表中插入10000条记录。”我怀疑100000条记录中的一次更新将比10000条记录中的10次更新快。在得出结论之前，我会尝试两种方法。在我上面的问题中，我不是想看哪一种更快，而是想弄清楚为什么在使用System.nanotime时我会得到
0毫秒
。如果我误解了你的建议，请纠正我。