From 5088fa8a3431ef42aeed2339d2771bf77c7a0231 Mon Sep 17 00:00:00 2001 From: wenshao Date: Sun, 7 Oct 2012 22:08:53 +0800 Subject: [PATCH] opimized memory used --- .../com/alibaba/druid/stat/JdbcSqlStat.java | 392 ++++++++++++++---- .../bvt/filter/StatFilterAfterResetTest.java | 21 +- .../StatFilterExecuteFirstResultSetTest.java | 6 +- .../bvt/filter/StatFilterExecuteTest.java | 9 +- .../StatFilterResultSetMultiCloseTest.java | 7 +- .../alibaba/druid/stat/JdbcSqlStatTest.java | 33 ++ 6 files changed, 350 insertions(+), 118 deletions(-) create mode 100644 src/test/java/com/alibaba/druid/stat/JdbcSqlStatTest.java diff --git a/src/main/java/com/alibaba/druid/stat/JdbcSqlStat.java b/src/main/java/com/alibaba/druid/stat/JdbcSqlStat.java index 7ee70e68ba..68aec80f59 100644 --- a/src/main/java/com/alibaba/druid/stat/JdbcSqlStat.java +++ b/src/main/java/com/alibaba/druid/stat/JdbcSqlStat.java @@ -29,7 +29,6 @@ import javax.management.openmbean.SimpleType; import com.alibaba.druid.proxy.DruidDriver; import com.alibaba.druid.proxy.jdbc.StatementExecuteType; -import com.alibaba.druid.util.Histogram; import com.alibaba.druid.util.IOUtils; import com.alibaba.druid.util.JMXUtils; @@ -54,29 +53,25 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { private volatile long resultSetHoldTimeNano; private volatile long executeAndResultSetHoldTime; - final static AtomicLongFieldUpdater executeBatchSizeTotalUpdater; - final static AtomicLongFieldUpdater executeBatchSizeMaxUpdater; - - final static AtomicLongFieldUpdater executeSuccessCountUpdater; - final static AtomicLongFieldUpdater executeSpanNanoTotalUpdater; - final static AtomicLongFieldUpdater executeSpanNanoMaxUpdater; - final static AtomicLongFieldUpdater runningCountUpdater; - final static AtomicLongFieldUpdater concurrentMaxUpdater; - final static AtomicLongFieldUpdater resultSetHoldTimeNanoUpdater; - final static AtomicLongFieldUpdater executeAndResultSetHoldTimeUpdater; - static { - executeBatchSizeTotalUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "executeBatchSizeTotal"); - executeBatchSizeMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "executeBatchSizeMax"); - - executeSuccessCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "executeSuccessCount"); - executeSpanNanoTotalUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "executeSpanNanoTotal"); - executeSpanNanoMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "executeSpanNanoMax"); - runningCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "runningCount"); - concurrentMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "concurrentMax"); - resultSetHoldTimeNanoUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "resultSetHoldTimeNano"); - executeAndResultSetHoldTimeUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, - "executeAndResultSetHoldTime"); - } + final static AtomicLongFieldUpdater executeBatchSizeTotalUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeBatchSizeTotal"); + final static AtomicLongFieldUpdater executeBatchSizeMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeBatchSizeMax"); + + final static AtomicLongFieldUpdater executeSuccessCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeSuccessCount"); + final static AtomicLongFieldUpdater executeSpanNanoTotalUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeSpanNanoTotal"); + final static AtomicLongFieldUpdater executeSpanNanoMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeSpanNanoMax"); + final static AtomicLongFieldUpdater runningCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "runningCount"); + final static AtomicLongFieldUpdater concurrentMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "concurrentMax"); + final static AtomicLongFieldUpdater resultSetHoldTimeNanoUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "resultSetHoldTimeNano"); + final static AtomicLongFieldUpdater executeAndResultSetHoldTimeUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultSetHoldTime"); private String name; private String file; @@ -97,7 +92,7 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { private String lastSlowParameters; - private boolean removed = false; + private boolean removed = false; private volatile long clobOpenCount; private volatile long blobOpenCount; @@ -107,60 +102,124 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { private volatile long inputStreamOpenCount; private volatile long readerOpenCount; - final static AtomicLongFieldUpdater executeErrorCountUpdater; - final static AtomicLongFieldUpdater updateCountUpdater; - final static AtomicLongFieldUpdater updateCountMaxUpdater; - final static AtomicLongFieldUpdater fetchRowCountUpdater; - final static AtomicLongFieldUpdater fetchRowCountMaxUpdater; - final static AtomicLongFieldUpdater inTransactionCountUpdater; + final static AtomicLongFieldUpdater executeErrorCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeErrorCount"); + final static AtomicLongFieldUpdater updateCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "updateCount"); + final static AtomicLongFieldUpdater updateCountMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "updateCountMax"); + final static AtomicLongFieldUpdater fetchRowCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "fetchRowCount"); + final static AtomicLongFieldUpdater fetchRowCountMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "fetchRowCountMax"); + final static AtomicLongFieldUpdater inTransactionCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "inTransactionCount"); - final static AtomicLongFieldUpdater clobOpenCountUpdater; - final static AtomicLongFieldUpdater blobOpenCountUpdater; - final static AtomicLongFieldUpdater readStringLengthUpdater; - final static AtomicLongFieldUpdater readBytesLengthUpdater; + final static AtomicLongFieldUpdater clobOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "clobOpenCount"); + final static AtomicLongFieldUpdater blobOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "blobOpenCount"); + final static AtomicLongFieldUpdater readStringLengthUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "readStringLength"); + final static AtomicLongFieldUpdater readBytesLengthUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "readBytesLength"); - final static AtomicLongFieldUpdater inputStreamOpenCountUpdater; - final static AtomicLongFieldUpdater readerOpenCountUpdater; + final static AtomicLongFieldUpdater inputStreamOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "inputStreamOpenCount"); + final static AtomicLongFieldUpdater readerOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "readerOpenCount"); - static { - executeErrorCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "executeErrorCount"); + private volatile long histogram_0_1; + private volatile long histogram_1_10; + private volatile long histogram_10_100; + private volatile long histogram_100_1000; + private volatile long histogram_1000_10000; + private volatile long histogram_10000_100000; + private volatile long histogram_100000_1000000; + private volatile long histogram_1000000_more; - updateCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "updateCount"); - updateCountMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "updateCountMax"); - fetchRowCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "fetchRowCount"); - fetchRowCountMaxUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "fetchRowCountMax"); - inTransactionCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "inTransactionCount"); + final static AtomicLongFieldUpdater histogram_0_1_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "histogram_0_1"); + final static AtomicLongFieldUpdater histogram_1_10_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "histogram_1_10"); + final static AtomicLongFieldUpdater histogram_10_100_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "histogram_10_100"); + final static AtomicLongFieldUpdater histogram_100_1000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "histogram_100_1000"); + final static AtomicLongFieldUpdater histogram_1000_10000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "histogram_1000_10000"); + final static AtomicLongFieldUpdater histogram_10000_100000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "histogram_10000_100000"); + final static AtomicLongFieldUpdater histogram_100000_1000000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "histogram_100000_1000000"); + final static AtomicLongFieldUpdater histogram_1000000_more_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "histogram_1000000_more"); - clobOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "clobOpenCount"); - blobOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "blobOpenCount"); - readStringLengthUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "readStringLength"); - readBytesLengthUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "readBytesLength"); + private volatile long executeAndResultHoldTime_0_1; + private volatile long executeAndResultHoldTime_1_10; + private volatile long executeAndResultHoldTime_10_100; + private volatile long executeAndResultHoldTime_100_1000; + private volatile long executeAndResultHoldTime_1000_10000; + private volatile long executeAndResultHoldTime_10000_100000; + private volatile long executeAndResultHoldTime_100000_1000000; + private volatile long executeAndResultHoldTime_1000000_more; - inputStreamOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "inputStreamOpenCount"); - readerOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, "readerOpenCount"); - } + final static AtomicLongFieldUpdater executeAndResultHoldTime_0_1_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultHoldTime_0_1"); + final static AtomicLongFieldUpdater executeAndResultHoldTime_1_10_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultHoldTime_1_10"); + final static AtomicLongFieldUpdater executeAndResultHoldTime_10_100_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultHoldTime_10_100"); + final static AtomicLongFieldUpdater executeAndResultHoldTime_100_1000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultHoldTime_100_1000"); + final static AtomicLongFieldUpdater executeAndResultHoldTime_1000_10000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultHoldTime_1000_10000"); + final static AtomicLongFieldUpdater executeAndResultHoldTime_10000_100000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultHoldTime_10000_100000"); + final static AtomicLongFieldUpdater executeAndResultHoldTime_100000_1000000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultHoldTime_100000_1000000"); + final static AtomicLongFieldUpdater executeAndResultHoldTime_1000000_more_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "executeAndResultHoldTime_1000000_more"); - private final Histogram histogram = new Histogram(new long[] { // - // - 1, 10, 100, 1000, 10 * 1000, // - 100 * 1000, 1000 * 1000 - // - }); + private volatile long fetchRowCount_0_1; + private volatile long fetchRowCount_1_10; + private volatile long fetchRowCount_10_100; + private volatile long fetchRowCount_100_1000; + private volatile long fetchRowCount_1000_10000; + private volatile long fetchRowCount_10000_more; - private final Histogram executeAndResultHoldTimeHistogram = new Histogram(new long[] { // - // - 1, 10, 100, 1000, 10 * 1000, // - 100 * 1000, 1000 * 1000 - // - }); + final static AtomicLongFieldUpdater fetchRowCount_0_1_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "fetchRowCount_0_1"); + final static AtomicLongFieldUpdater fetchRowCount_1_10_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "fetchRowCount_1_10"); + final static AtomicLongFieldUpdater fetchRowCount_10_100_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "fetchRowCount_10_100"); + final static AtomicLongFieldUpdater fetchRowCount_100_1000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "fetchRowCount_100_1000"); + final static AtomicLongFieldUpdater fetchRowCount_1000_10000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "fetchRowCount_1000_10000"); + final static AtomicLongFieldUpdater fetchRowCount_10000_more_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "fetchRowCount_10000_more"); - private final Histogram fetchRowCountHistogram = new Histogram(new long[] { // - 1, 10, 100, - 1000, 10 * 1000 }); + private volatile long updateCount_0_1; + private volatile long updateCount_1_10; + private volatile long updateCount_10_100; + private volatile long updateCount_100_1000; + private volatile long updateCount_1000_10000; + private volatile long updateCount_10000_more; - private final Histogram updateCountHistogram = new Histogram(new long[] { // - 1, 10, 100, - 1000, 10 * 1000 }); + final static AtomicLongFieldUpdater updateCount_0_1_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "updateCount_0_1"); + final static AtomicLongFieldUpdater updateCount_1_10_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "updateCount_1_10"); + final static AtomicLongFieldUpdater updateCount_10_100_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "updateCount_10_100"); + final static AtomicLongFieldUpdater updateCount_100_1000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "updateCount_100_1000"); + final static AtomicLongFieldUpdater updateCount_1000_10000_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "updateCount_1000_10000"); + final static AtomicLongFieldUpdater updateCount_10000_more_Updater = AtomicLongFieldUpdater.newUpdater(JdbcSqlStat.class, + "updateCount_10000_more"); public JdbcSqlStat(String sql){ this.sql = sql; @@ -279,14 +338,42 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { fetchRowCountUpdater.set(this, 0); fetchRowCountMaxUpdater.set(this, 0); - histogram.reset(); + histogram_0_1_Updater.set(this, 0); + histogram_1_10_Updater.set(this, 0); + histogram_10_100_Updater.set(this, 0); + histogram_100_1000_Updater.set(this, 0); + histogram_1000_10000_Updater.set(this, 0); + histogram_10000_100000_Updater.set(this, 0); + histogram_100000_1000000_Updater.set(this, 0); + histogram_1000000_more_Updater.set(this, 0); + this.lastSlowParameters = null; inTransactionCountUpdater.set(this, 0); resultSetHoldTimeNanoUpdater.set(this, 0); executeAndResultSetHoldTimeUpdater.set(this, 0); - fetchRowCountHistogram.reset(); - updateCountHistogram.reset(); - executeAndResultHoldTimeHistogram.reset(); + + fetchRowCount_0_1_Updater.set(this, 0); + fetchRowCount_1_10_Updater.set(this, 0); + fetchRowCount_10_100_Updater.set(this, 0); + fetchRowCount_100_1000_Updater.set(this, 0); + fetchRowCount_1000_10000_Updater.set(this, 0); + fetchRowCount_10000_more_Updater.set(this, 0); + + updateCount_0_1_Updater.set(this, 0); + updateCount_1_10_Updater.set(this, 0); + updateCount_10_100_Updater.set(this, 0); + updateCount_100_1000_Updater.set(this, 0); + updateCount_1000_10000_Updater.set(this, 0); + updateCount_10000_more_Updater.set(this, 0); + + executeAndResultHoldTime_0_1_Updater.set(this, 0); + executeAndResultHoldTime_1_10_Updater.set(this, 0); + executeAndResultHoldTime_10_100_Updater.set(this, 0); + executeAndResultHoldTime_100_1000_Updater.set(this, 0); + executeAndResultHoldTime_1000_10000_Updater.set(this, 0); + executeAndResultHoldTime_10000_100000_Updater.set(this, 0); + executeAndResultHoldTime_100000_1000000_Updater.set(this, 0); + executeAndResultHoldTime_1000000_more_Updater.set(this, 0); blobOpenCountUpdater.set(this, 0); clobOpenCountUpdater.set(this, 0); @@ -318,7 +405,19 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { } } - this.updateCountHistogram.record(delta); + if (delta < 1) { + updateCount_0_1_Updater.incrementAndGet(this); + } else if (delta < 10) { + updateCount_1_10_Updater.incrementAndGet(this); + } else if (delta < 100) { + updateCount_10_100_Updater.incrementAndGet(this); + } else if (delta < 1000) { + updateCount_100_1000_Updater.incrementAndGet(this); + } else if (delta < 10000) { + updateCount_1000_10000_Updater.incrementAndGet(this); + } else { + updateCount_10000_more_Updater.incrementAndGet(this); + } } public long getUpdateCount() { @@ -434,7 +533,20 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { break; } } - this.fetchRowCountHistogram.record(delta); + + if (delta < 1) { + fetchRowCount_0_1_Updater.incrementAndGet(this); + } else if (delta < 10) { + fetchRowCount_1_10_Updater.incrementAndGet(this); + } else if (delta < 100) { + fetchRowCount_10_100_Updater.incrementAndGet(this); + } else if (delta < 1000) { + fetchRowCount_100_1000_Updater.incrementAndGet(this); + } else if (delta < 10000) { + fetchRowCount_1000_10000_Updater.incrementAndGet(this); + } else { + fetchRowCount_10000_more_Updater.incrementAndGet(this); + } } @@ -497,7 +609,51 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { addExecuteTime(nanoSpan); if (StatementExecuteType.ExecuteQuery != executeType && !firstResultSet) { - executeAndResultHoldTimeHistogram.record((nanoSpan) / 1000 / 1000); + executeAndResultHoldTimeHistogramRecord(nanoSpan); + } + } + + private void executeAndResultHoldTimeHistogramRecord(long nanoSpan) { + long millis = nanoSpan / 1000 / 1000; + + if (millis < 1) { + executeAndResultHoldTime_0_1_Updater.incrementAndGet(this); + } else if (millis < 10) { + executeAndResultHoldTime_1_10_Updater.incrementAndGet(this); + } else if (millis < 100) { + executeAndResultHoldTime_10_100_Updater.incrementAndGet(this); + } else if (millis < 1000) { + executeAndResultHoldTime_100_1000_Updater.incrementAndGet(this); + } else if (millis < 10000) { + executeAndResultHoldTime_1000_10000_Updater.incrementAndGet(this); + } else if (millis < 100000) { + executeAndResultHoldTime_10000_100000_Updater.incrementAndGet(this); + } else if (millis < 1000000) { + executeAndResultHoldTime_100000_1000000_Updater.incrementAndGet(this); + } else { + executeAndResultHoldTime_1000000_more_Updater.incrementAndGet(this); + } + } + + private void histogramRecord(long nanoSpan) { + long millis = nanoSpan / 1000 / 1000; + + if (millis < 1) { + histogram_0_1_Updater.incrementAndGet(this); + } else if (millis < 10) { + histogram_1_10_Updater.incrementAndGet(this); + } else if (millis < 100) { + histogram_10_100_Updater.incrementAndGet(this); + } else if (millis < 1000) { + histogram_100_1000_Updater.incrementAndGet(this); + } else if (millis < 10000) { + histogram_1000_10000_Updater.incrementAndGet(this); + } else if (millis < 100000) { + histogram_10000_100000_Updater.incrementAndGet(this); + } else if (millis < 1000000) { + histogram_100000_1000000_Updater.incrementAndGet(this); + } else { + histogram_1000000_more_Updater.incrementAndGet(this); } } @@ -521,7 +677,7 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { } long millis = nanoSpan / (1000 * 1000); - histogram.record(millis); + histogramRecord(millis); } public long getExecuteMillisTotal() { @@ -735,14 +891,14 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { map.put("URL", null); // 23 map.put("InTransactionCount", getInTransactionCount()); // 24 - map.put("Histogram", this.histogram.toArray()); // 25 + map.put("Histogram", this.getHistogramValues()); // 25 map.put("LastSlowParameters", lastSlowParameters); // 26 map.put("ResultSetHoldTime", getResultSetHoldTimeMilis()); // 27 map.put("ExecuteAndResultSetHoldTime", this.getExecuteAndResultSetHoldTimeMilis()); // 28 - map.put("FetchRowCountHistogram", this.getFetchRowCountHistogram().toArray()); // 29 + map.put("FetchRowCountHistogram", this.getFetchRowCountHistogramValues()); // 29 - map.put("EffectedRowCountHistogram", this.getUpdateCountHistogram().toArray()); // 30 - map.put("ExecuteAndResultHoldTimeHistogram", this.getExecuteAndResultHoldTimeHistogram().toArray()); // 31 + map.put("EffectedRowCountHistogram", this.getUpdateCountHistogramValues()); // 30 + map.put("ExecuteAndResultHoldTimeHistogram", this.getExecuteAndResultHoldTimeHistogramValues()); // 31 map.put("EffectedRowCountMax", getUpdateCountMax()); // 32 map.put("FetchRowCountMax", getFetchRowCountMax()); // 33 map.put("ClobOpenCount", getClobOpenCount()); // 34 @@ -756,8 +912,27 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { return map; } - public Histogram getHistogram() { - return this.histogram; + public long[] getHistogramValues() { + return new long[] { + // + histogram_0_1, // + histogram_1_10, // + histogram_10_100, // + histogram_100_1000, // + histogram_1000_10000, // + histogram_10000_100000, // + histogram_100000_1000000, // + histogram_1000000_more // + }; + } + + public long getHistogramSum() { + long[] values = this.getHistogramValues(); + long sum = 0; + for (int i = 0; i < values.length; ++i) { + sum += values[i]; + } + return sum; } public CompositeDataSupport getCompositeData() throws JMException { @@ -783,16 +958,51 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { return getExecuteAndResultSetHoldTimeNano() / (1000 * 1000); } - public Histogram getFetchRowCountHistogram() { - return this.fetchRowCountHistogram; + public long[] getFetchRowCountHistogramValues() { + return new long[] { + // + fetchRowCount_0_1, // + fetchRowCount_1_10, // + fetchRowCount_10_100, // + fetchRowCount_100_1000, // + fetchRowCount_1000_10000, // + fetchRowCount_10000_more // + }; } - public Histogram getUpdateCountHistogram() { - return this.updateCountHistogram; + public long[] getUpdateCountHistogramValues() { + return new long[] { + // + updateCount_0_1, // + updateCount_1_10, // + updateCount_10_100, // + updateCount_100_1000, // + updateCount_1000_10000, // + updateCount_10000_more // + }; } - public Histogram getExecuteAndResultHoldTimeHistogram() { - return this.executeAndResultHoldTimeHistogram; + public long[] getExecuteAndResultHoldTimeHistogramValues() { + return new long[] { + // + executeAndResultHoldTime_0_1, // + executeAndResultHoldTime_1_10, // + executeAndResultHoldTime_10_100, // + executeAndResultHoldTime_100_1000, // + executeAndResultHoldTime_1000_10000, // + executeAndResultHoldTime_10000_100000, // + executeAndResultHoldTime_100000_1000000, // + executeAndResultHoldTime_1000000_more // + }; + } + + public long getExecuteAndResultHoldTimeHistogramSum() { + long[] values = this.getExecuteAndResultHoldTimeHistogramValues(); + long sum = 0; + for (int i = 0; i < values.length; ++i) { + sum += values[i]; + } + return sum; } public long getResultSetHoldTimeNano() { @@ -810,8 +1020,8 @@ public final class JdbcSqlStat implements JdbcSqlStatMBean { public void addResultSetHoldTimeNano(long statementExecuteNano, long resultHoldTimeNano) { resultSetHoldTimeNanoUpdater.addAndGet(this, resultHoldTimeNano); executeAndResultSetHoldTimeUpdater.addAndGet(this, statementExecuteNano + resultHoldTimeNano); - executeAndResultHoldTimeHistogram.record((statementExecuteNano + resultHoldTimeNano) / 1000 / 1000); - updateCountHistogram.record(0); + executeAndResultHoldTimeHistogramRecord((statementExecuteNano + resultHoldTimeNano) / 1000 / 1000); + updateCount_0_1_Updater.incrementAndGet(this); } public boolean isRemoved() { diff --git a/src/test/java/com/alibaba/druid/bvt/filter/StatFilterAfterResetTest.java b/src/test/java/com/alibaba/druid/bvt/filter/StatFilterAfterResetTest.java index ea2d5773d8..e03cc7b530 100644 --- a/src/test/java/com/alibaba/druid/bvt/filter/StatFilterAfterResetTest.java +++ b/src/test/java/com/alibaba/druid/bvt/filter/StatFilterAfterResetTest.java @@ -64,20 +64,17 @@ public class StatFilterAfterResetTest extends TestCase { sqlStat = dataSource.getDataSourceStat().getSqlStat(sql); Assert.assertNotNull(sqlStat); - Histogram histogram = sqlStat.getExecuteAndResultHoldTimeHistogram(); - Assert.assertEquals("first failed", 1, - histogram.getSum()); + Assert.assertEquals("first failed", 1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); rs.close(); - Assert.assertEquals("second failed", 1, - histogram.getSum()); + Assert.assertEquals("second failed", 1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); stmt.close(); conn.close(); - Assert.assertEquals(1, histogram.getSum()); + Assert.assertEquals(1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); } JdbcStatManager.getInstance().reset(); @@ -97,15 +94,13 @@ public class StatFilterAfterResetTest extends TestCase { } Assert.assertNotSame(sqlStat, dataSource.getDataSourceStat().getSqlStat(sql)); - + { - Histogram histogram = sqlStat.getExecuteAndResultHoldTimeHistogram(); - Assert.assertEquals(0, histogram.getValue(0) + histogram.getValue(1) + histogram.getValue(2)); + Assert.assertEquals(0, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); } - + sqlStat = dataSource.getDataSourceStat().getSqlStat(sql); - - Histogram histogram = sqlStat.getExecuteAndResultHoldTimeHistogram(); - Assert.assertEquals(1, histogram.getValue(0) + histogram.getValue(1) + histogram.getValue(2)); + + Assert.assertEquals(1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); } } diff --git a/src/test/java/com/alibaba/druid/bvt/filter/StatFilterExecuteFirstResultSetTest.java b/src/test/java/com/alibaba/druid/bvt/filter/StatFilterExecuteFirstResultSetTest.java index 84a9049054..7002b27692 100644 --- a/src/test/java/com/alibaba/druid/bvt/filter/StatFilterExecuteFirstResultSetTest.java +++ b/src/test/java/com/alibaba/druid/bvt/filter/StatFilterExecuteFirstResultSetTest.java @@ -79,12 +79,10 @@ public class StatFilterExecuteFirstResultSetTest extends TestCase { JdbcSqlStat sqlStat = dataSource.getDataSourceStat().getSqlStat(sql); - Histogram histogram = sqlStat.getHistogram(); - Assert.assertEquals(1, histogram.getSum()); + Assert.assertEquals(1, sqlStat.getHistogramSum()); - Histogram rsHoldHistogram = sqlStat.getExecuteAndResultHoldTimeHistogram(); - Assert.assertEquals(1, rsHoldHistogram.getSum()); + Assert.assertEquals(1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); } static class MyMockPreparedStatement extends MockPreparedStatement { diff --git a/src/test/java/com/alibaba/druid/bvt/filter/StatFilterExecuteTest.java b/src/test/java/com/alibaba/druid/bvt/filter/StatFilterExecuteTest.java index 4444983184..546ae1acf3 100644 --- a/src/test/java/com/alibaba/druid/bvt/filter/StatFilterExecuteTest.java +++ b/src/test/java/com/alibaba/druid/bvt/filter/StatFilterExecuteTest.java @@ -67,7 +67,7 @@ public class StatFilterExecuteTest extends TestCase { PreparedStatement stmt = conn.prepareStatement(sql); - Assert.assertEquals(0, dataSource.getDataSourceStat().getSqlStat(sql).getExecuteAndResultHoldTimeHistogram().getSum()); + Assert.assertEquals(0, dataSource.getDataSourceStat().getSqlStat(sql).getExecuteAndResultHoldTimeHistogramSum()); boolean firstResult = stmt.execute(); Assert.assertFalse(firstResult); @@ -78,12 +78,9 @@ public class StatFilterExecuteTest extends TestCase { JdbcSqlStat sqlStat = dataSource.getDataSourceStat().getSqlStat(sql); - Histogram histogram = sqlStat.getHistogram(); - Assert.assertEquals(1, histogram.getSum()); + Assert.assertEquals(1, sqlStat.getHistogramSum()); - Histogram rsHoldHistogram = sqlStat.getExecuteAndResultHoldTimeHistogram(); - - Assert.assertEquals(1, rsHoldHistogram.getSum()); + Assert.assertEquals(1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); } static class MyMockPreparedStatement extends MockPreparedStatement { diff --git a/src/test/java/com/alibaba/druid/bvt/filter/StatFilterResultSetMultiCloseTest.java b/src/test/java/com/alibaba/druid/bvt/filter/StatFilterResultSetMultiCloseTest.java index 1ef68880e8..948a7efd22 100644 --- a/src/test/java/com/alibaba/druid/bvt/filter/StatFilterResultSetMultiCloseTest.java +++ b/src/test/java/com/alibaba/druid/bvt/filter/StatFilterResultSetMultiCloseTest.java @@ -66,17 +66,16 @@ public class StatFilterResultSetMultiCloseTest extends TestCase { sqlStat = dataSource.getDataSourceStat().getSqlStat(sql); Assert.assertNotNull(sqlStat); - Histogram histogram = sqlStat.getExecuteAndResultHoldTimeHistogram(); - Assert.assertEquals("first failed", 1, histogram.getValue(0) + histogram.getValue(1) + histogram.getValue(2)); + Assert.assertEquals("first failed", 1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); rs.close(); - Assert.assertEquals("second failed", 1, histogram.getValue(0) + histogram.getValue(1) + histogram.getValue(2)); + Assert.assertEquals("second failed", 1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); stmt.close(); conn.close(); - Assert.assertEquals(1, histogram.getValue(0) + histogram.getValue(1) + histogram.getValue(2)); + Assert.assertEquals(1, sqlStat.getExecuteAndResultHoldTimeHistogramSum()); } } diff --git a/src/test/java/com/alibaba/druid/stat/JdbcSqlStatTest.java b/src/test/java/com/alibaba/druid/stat/JdbcSqlStatTest.java new file mode 100644 index 0000000000..ef6f196b0c --- /dev/null +++ b/src/test/java/com/alibaba/druid/stat/JdbcSqlStatTest.java @@ -0,0 +1,33 @@ +package com.alibaba.druid.stat; + +import java.lang.management.ManagementFactory; +import java.text.NumberFormat; + +import junit.framework.TestCase; + +public class JdbcSqlStatTest extends TestCase { + private JdbcSqlStat item; + + public void test_0() throws Exception { + item = new JdbcSqlStat(""); + gc(); + long memoryStart = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed(); + + final int COUNT = 1024 * 1024; + JdbcSqlStat[] items = new JdbcSqlStat[COUNT]; + for (int i = 0; i < COUNT; ++i) { + items[i] = new JdbcSqlStat(""); + // items[i] = Histogram.makeHistogram(20); + } + + long memoryEnd = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed(); + + System.out.println("memory used : " + NumberFormat.getInstance().format(memoryEnd - memoryStart)); + } + + private void gc() { + for (int i = 0; i < 10; ++i) { + System.gc(); + } + } +}