From 68a27430fbce7a5ed5770b82030f033378e9785f Mon Sep 17 00:00:00 2001 From: wenshao Date: Sun, 7 Oct 2012 20:53:02 +0800 Subject: [PATCH] use AtomicLongFieldUpdater instead of AtomicLong --- .../support/http/stat/WebSessionStat.java | 136 +++++++----- .../druid/support/http/stat/WebURIStat.java | 193 +++++++++++------- 2 files changed, 202 insertions(+), 127 deletions(-) diff --git a/src/main/java/com/alibaba/druid/support/http/stat/WebSessionStat.java b/src/main/java/com/alibaba/druid/support/http/stat/WebSessionStat.java index 3ad9056484..320207bb6c 100644 --- a/src/main/java/com/alibaba/druid/support/http/stat/WebSessionStat.java +++ b/src/main/java/com/alibaba/druid/support/http/stat/WebSessionStat.java @@ -20,39 +20,63 @@ import java.util.HashSet; import java.util.LinkedHashMap; import java.util.Map; import java.util.Set; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; +import java.util.concurrent.atomic.AtomicLongFieldUpdater; import com.alibaba.druid.util.Histogram; public class WebSessionStat { - private final String sessionId; + private final String sessionId; - private final AtomicInteger runningCount = new AtomicInteger(); - private final AtomicInteger concurrentMax = new AtomicInteger(); - private final AtomicLong requestCount = new AtomicLong(0); - private final AtomicLong requestErrorCount = new AtomicLong(0); - private final AtomicLong requestTimeNano = new AtomicLong(); + private volatile int runningCount; + private volatile int concurrentMax; + final static AtomicIntegerFieldUpdater runningCountUpdater = AtomicIntegerFieldUpdater.newUpdater(WebSessionStat.class, + "runningCount"); + final static AtomicIntegerFieldUpdater concurrentMaxUpdater = AtomicIntegerFieldUpdater.newUpdater(WebSessionStat.class, + "concurrentMax"); - private final AtomicLong jdbcFetchRowCount = new AtomicLong(); - private final AtomicLong jdbcUpdateCount = new AtomicLong(); - private final AtomicLong jdbcExecuteCount = new AtomicLong(); - private final AtomicLong jdbcExecuteTimeNano = new AtomicLong(); + private volatile long requestCount; + private volatile long requestErrorCount; + private volatile long requestTimeNano; - private final AtomicLong jdbcCommitCount = new AtomicLong(); - private final AtomicLong jdbcRollbackCount = new AtomicLong(); + final static AtomicLongFieldUpdater requestCountUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "requestCount"); + final static AtomicLongFieldUpdater requestErrorCountUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "requestErrorCount"); + final static AtomicLongFieldUpdater requestTimeNanoUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "requestTimeNano"); - private long createTimeMillis = -1L; - private volatile long lastAccessTimeMillis = -1L; + private volatile long jdbcFetchRowCount; + private volatile long jdbcUpdateCount; + private volatile long jdbcExecuteCount; + private volatile long jdbcExecuteTimeNano; + final static AtomicLongFieldUpdater jdbcFetchRowCountUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "jdbcFetchRowCount"); + final static AtomicLongFieldUpdater jdbcUpdateCountUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "jdbcUpdateCount"); + final static AtomicLongFieldUpdater jdbcExecuteCountUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "jdbcExecuteCount"); + final static AtomicLongFieldUpdater jdbcExecuteTimeNanoUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "jdbcExecuteTimeNano"); - private Set remoteAddresses = new HashSet(); + private volatile long jdbcCommitCount; + private volatile long jdbcRollbackCount; + final static AtomicLongFieldUpdater jdbcCommitCountUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "jdbcCommitCount"); + final static AtomicLongFieldUpdater jdbcRollbackCountUpdater = AtomicLongFieldUpdater.newUpdater(WebSessionStat.class, + "jdbcRollbackCount"); - private String principal = null; + private long createTimeMillis = -1L; + private volatile long lastAccessTimeMillis = -1L; - private String userAgent; + private Set remoteAddresses = new HashSet(2); - private Histogram requestIntervalHistogram = Histogram.makeHistogram(8); + private String principal = null; + + private String userAgent; + + private Histogram requestIntervalHistogram = Histogram.makeHistogram(8); public WebSessionStat(String sessionId){ super(); @@ -60,17 +84,17 @@ public class WebSessionStat { } public void reset() { - concurrentMax.set(0); - requestCount.set(0); - requestErrorCount.set(0); - requestTimeNano.set(0); + concurrentMaxUpdater.set(this, 0); + requestCountUpdater.set(this, 0); + requestErrorCountUpdater.set(this, 0); + requestTimeNanoUpdater.set(this, 0); - jdbcFetchRowCount.set(0); - jdbcUpdateCount.set(0); - jdbcExecuteCount.set(0); - jdbcExecuteTimeNano.set(0); - jdbcCommitCount.set(0); - jdbcRollbackCount.set(0); + jdbcFetchRowCountUpdater.set(this, 0); + jdbcUpdateCountUpdater.set(this, 0); + jdbcExecuteCountUpdater.set(this, 0); + jdbcExecuteTimeNanoUpdater.set(this, 0); + jdbcCommitCountUpdater.set(this, 0); + jdbcRollbackCountUpdater.set(this, 0); remoteAddresses.clear(); principal = null; @@ -159,12 +183,12 @@ public class WebSessionStat { } public void beforeInvoke() { - int running = runningCount.incrementAndGet(); + int running = runningCountUpdater.incrementAndGet(this); for (;;) { - int max = concurrentMax.get(); + int max = concurrentMaxUpdater.get(this); if (running > max) { - if (concurrentMax.compareAndSet(max, running)) { + if (concurrentMaxUpdater.compareAndSet(this, max, running)) { break; } else { continue; @@ -183,16 +207,16 @@ public class WebSessionStat { } public void incrementRequestCount() { - requestCount.incrementAndGet(); + requestCountUpdater.incrementAndGet(this); } public void afterInvoke(Throwable error, long nanos) { - runningCount.decrementAndGet(); + runningCountUpdater.decrementAndGet(this); reacord(nanos); } public void reacord(long nanos) { - requestTimeNano.addAndGet(nanos); + requestTimeNanoUpdater.addAndGet(this, nanos); WebRequestStat requestStat = WebRequestStat.current(); if (requestStat != null) { @@ -210,23 +234,23 @@ public class WebSessionStat { } public int getRunningCount() { - return this.runningCount.get(); + return this.runningCount; } public long getConcurrentMax() { - return concurrentMax.get(); + return concurrentMax; } public long getRequestCount() { - return requestCount.get(); + return requestCount; } public long getRequestErrorCount() { - return requestErrorCount.get(); + return requestErrorCount; } public long getRequestTimeNano() { - return requestTimeNano.get(); + return requestTimeNano; } public long getRequestTimeMillis() { @@ -234,31 +258,31 @@ public class WebSessionStat { } public void addJdbcFetchRowCount(long delta) { - this.jdbcFetchRowCount.addAndGet(delta); + jdbcFetchRowCountUpdater.addAndGet(this, delta); } public long getJdbcFetchRowCount() { - return jdbcFetchRowCount.get(); + return jdbcFetchRowCount; } public void addJdbcUpdateCount(long updateCount) { - this.jdbcUpdateCount.addAndGet(updateCount); + jdbcUpdateCountUpdater.addAndGet(this, updateCount); } public long getJdbcUpdateCount() { - return jdbcUpdateCount.get(); + return jdbcUpdateCount; } public void incrementJdbcExecuteCount() { - jdbcExecuteCount.incrementAndGet(); + jdbcExecuteCountUpdater.incrementAndGet(this); } public void addJdbcExecuteCount(long executeCount) { - jdbcExecuteCount.addAndGet(executeCount); + jdbcExecuteCountUpdater.addAndGet(this, executeCount); } public long getJdbcExecuteCount() { - return jdbcExecuteCount.get(); + return jdbcExecuteCount; } public long getJdbcExecuteTimeMillis() { @@ -266,35 +290,35 @@ public class WebSessionStat { } public long getJdbcExecuteTimeNano() { - return jdbcExecuteTimeNano.get(); + return jdbcExecuteTimeNano; } public void addJdbcExecuteTimeNano(long nano) { - jdbcExecuteTimeNano.addAndGet(nano); + jdbcExecuteTimeNanoUpdater.addAndGet(this, nano); } public void incrementJdbcCommitCount() { - jdbcCommitCount.incrementAndGet(); + jdbcCommitCountUpdater.incrementAndGet(this); } public long getJdbcCommitCount() { - return jdbcCommitCount.get(); + return jdbcCommitCount; } public void addJdbcCommitCount(long commitCount) { - this.jdbcCommitCount.addAndGet(commitCount); + jdbcCommitCountUpdater.addAndGet(this, commitCount); } public void incrementJdbcRollbackCount() { - jdbcRollbackCount.incrementAndGet(); + jdbcRollbackCountUpdater.incrementAndGet(this); } public long getJdbcRollbackCount() { - return jdbcRollbackCount.get(); + return jdbcRollbackCount; } public void addJdbcRollbackCount(long rollbackCount) { - this.jdbcRollbackCount.addAndGet(rollbackCount); + jdbcRollbackCountUpdater.addAndGet(this, rollbackCount); } public long[] getRequestInterval() { diff --git a/src/main/java/com/alibaba/druid/support/http/stat/WebURIStat.java b/src/main/java/com/alibaba/druid/support/http/stat/WebURIStat.java index fffd2fa481..c41b97b949 100644 --- a/src/main/java/com/alibaba/druid/support/http/stat/WebURIStat.java +++ b/src/main/java/com/alibaba/druid/support/http/stat/WebURIStat.java @@ -18,48 +18,93 @@ package com.alibaba.druid.support.http.stat; import java.util.Date; import java.util.LinkedHashMap; import java.util.Map; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; +import java.util.concurrent.atomic.AtomicLongFieldUpdater; +import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; import com.alibaba.druid.support.profile.ProfileStat; import com.alibaba.druid.support.profile.Profiler; public class WebURIStat { - private final String uri; + private final String uri; - private final AtomicInteger runningCount = new AtomicInteger(); - private final AtomicInteger concurrentMax = new AtomicInteger(); - private final AtomicLong requestCount = new AtomicLong(0); - private final AtomicLong requestTimeNano = new AtomicLong(); + private volatile int runningCount; + private volatile int concurrentMax; + private volatile long requestCount; + private volatile long requestTimeNano; + final static AtomicIntegerFieldUpdater runningCountUpdater = AtomicIntegerFieldUpdater.newUpdater(WebURIStat.class, + "runningCount"); + final static AtomicIntegerFieldUpdater concurrentMaxUpdater = AtomicIntegerFieldUpdater.newUpdater(WebURIStat.class, + "concurrentMax"); + final static AtomicLongFieldUpdater requestCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "requestCount"); + final static AtomicLongFieldUpdater requestTimeNanoUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "requestTimeNano"); - private final AtomicLong jdbcFetchRowCount = new AtomicLong(); - private final AtomicLong jdbcFetchRowPeak = new AtomicLong(); // 单次请求读取行数的峰值 + private volatile long jdbcFetchRowCount; + private volatile long jdbcFetchRowPeak; // 单次请求读取行数的峰值 + final static AtomicLongFieldUpdater jdbcFetchRowCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcFetchRowCount"); + final static AtomicLongFieldUpdater jdbcFetchRowPeakUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcFetchRowPeak"); - private final AtomicLong jdbcUpdateCount = new AtomicLong(); - private final AtomicLong jdbcUpdatePeak = new AtomicLong(); // 单次请求更新行数的峰值 + private volatile long jdbcUpdateCount; + private volatile long jdbcUpdatePeak; // 单次请求更新行数的峰值 + final static AtomicLongFieldUpdater jdbcUpdateCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcUpdateCount"); + final static AtomicLongFieldUpdater jdbcUpdatePeakUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcUpdatePeak"); - private final AtomicLong jdbcExecuteCount = new AtomicLong(); - private final AtomicLong jdbcExecuteErrorCount = new AtomicLong(); - private final AtomicLong jdbcExecutePeak = new AtomicLong(); // 单次请求执行SQL次数的峰值 - private final AtomicLong jdbcExecuteTimeNano = new AtomicLong(); + private volatile long jdbcExecuteCount; + private volatile long jdbcExecuteErrorCount; + private volatile long jdbcExecutePeak; // 单次请求执行SQL次数的峰值 + private volatile long jdbcExecuteTimeNano; + final static AtomicLongFieldUpdater jdbcExecuteCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcExecuteCount"); + final static AtomicLongFieldUpdater jdbcExecuteErrorCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcExecuteErrorCount"); + final static AtomicLongFieldUpdater jdbcExecutePeakUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcExecutePeak"); + final static AtomicLongFieldUpdater jdbcExecuteTimeNanoUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcExecuteTimeNano"); - private final AtomicLong jdbcCommitCount = new AtomicLong(); - private final AtomicLong jdbcRollbackCount = new AtomicLong(); + private volatile long jdbcCommitCount; + private volatile long jdbcRollbackCount; + final static AtomicLongFieldUpdater jdbcCommitCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcCommitCount"); + final static AtomicLongFieldUpdater jdbcRollbackCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcRollbackCount"); - private final AtomicLong jdbcPoolConnectionOpenCount = new AtomicLong(); - private final AtomicLong jdbcPoolConnectionCloseCount = new AtomicLong(); + private volatile long jdbcPoolConnectionOpenCount; + private volatile long jdbcPoolConnectionCloseCount; + final static AtomicLongFieldUpdater jdbcPoolConnectionOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcPoolConnectionOpenCount"); + final static AtomicLongFieldUpdater jdbcPoolConnectionCloseCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcPoolConnectionCloseCount"); - private final AtomicLong jdbcResultSetOpenCount = new AtomicLong(); - private final AtomicLong jdbcResultSetCloseCount = new AtomicLong(); + private volatile long jdbcResultSetOpenCount; + private volatile long jdbcResultSetCloseCount; - private final AtomicLong errorCount = new AtomicLong(); + private volatile long errorCount; - private volatile long lastAccessTimeMillis = -1L; + private volatile long lastAccessTimeMillis = -1L; - private ProfileStat profiletat = new ProfileStat(); + private volatile ProfileStat profiletat; - private final static ThreadLocal currentLocal = new ThreadLocal(); + final static AtomicLongFieldUpdater jdbcResultSetOpenCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcResultSetOpenCount"); + final static AtomicLongFieldUpdater jdbcResultSetCloseCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "jdbcResultSetCloseCount"); + final static AtomicLongFieldUpdater errorCountUpdater = AtomicLongFieldUpdater.newUpdater(WebURIStat.class, + "errorCount"); + final static AtomicReferenceFieldUpdater profiletatUpdater; + + static { + profiletatUpdater = AtomicReferenceFieldUpdater.newUpdater(WebURIStat.class, ProfileStat.class, "profiletat"); + } + + private final static ThreadLocal currentLocal = new ThreadLocal(); public WebURIStat(String uri){ super(); @@ -77,12 +122,12 @@ public class WebURIStat { public void beforeInvoke() { currentLocal.set(this); - int running = runningCount.incrementAndGet(); + int running = runningCountUpdater.incrementAndGet(this); for (;;) { - int max = concurrentMax.get(); + int max = concurrentMaxUpdater.get(this); if (running > max) { - if (concurrentMax.compareAndSet(max, running)) { + if (concurrentMaxUpdater.compareAndSet(this, max, running)) { break; } else { continue; @@ -92,7 +137,7 @@ public class WebURIStat { } } - requestCount.incrementAndGet(); + requestCountUpdater.incrementAndGet(this); WebRequestStat requestStat = WebRequestStat.current(); if (requestStat != null) { @@ -103,11 +148,11 @@ public class WebURIStat { } public void afterInvoke(Throwable error, long nanos) { - runningCount.decrementAndGet(); - requestTimeNano.addAndGet(nanos); + runningCountUpdater.decrementAndGet(this); + requestTimeNanoUpdater.addAndGet(this, nanos); if (error != null) { - errorCount.incrementAndGet(); + errorCountUpdater.incrementAndGet(this); } { @@ -118,12 +163,12 @@ public class WebURIStat { this.addJdbcFetchRowCount(fetchRowCount); for (;;) { - long peak = jdbcFetchRowPeak.get(); + long peak = jdbcFetchRowPeakUpdater.get(this); if (fetchRowCount <= peak) { break; } - if (jdbcFetchRowPeak.compareAndSet(peak, fetchRowCount)) { + if (jdbcFetchRowPeakUpdater.compareAndSet(this, peak, fetchRowCount)) { break; } } @@ -133,12 +178,12 @@ public class WebURIStat { this.addJdbcExecuteCount(executeCount); for (;;) { - long peak = jdbcExecutePeak.get(); + long peak = jdbcExecutePeakUpdater.get(this); if (executeCount <= peak) { break; } - if (jdbcExecutePeak.compareAndSet(peak, executeCount)) { + if (jdbcExecutePeakUpdater.compareAndSet(this, peak, executeCount)) { break; } } @@ -148,19 +193,19 @@ public class WebURIStat { this.addJdbcUpdateCount(updateCount); for (;;) { - long peak = jdbcUpdatePeak.get(); + long peak = jdbcUpdatePeakUpdater.get(this); if (updateCount <= peak) { break; } - if (jdbcUpdatePeak.compareAndSet(peak, updateCount)) { + if (jdbcUpdatePeakUpdater.compareAndSet(this, peak, updateCount)) { break; } } } - this.jdbcExecuteErrorCount.addAndGet(localStat.getJdbcExecuteErrorCount()); - this.jdbcExecuteTimeNano.addAndGet(localStat.getJdbcExecuteTimeNano()); + jdbcExecuteErrorCountUpdater.addAndGet(this, localStat.getJdbcExecuteErrorCount()); + jdbcExecuteTimeNanoUpdater.addAndGet(this, localStat.getJdbcExecuteTimeNano()); this.addJdbcPoolConnectionOpenCount(localStat.getJdbcPoolConnectionOpenCount()); this.addJdbcPoolConnectionCloseCount(localStat.getJdbcPoolConnectionCloseCount()); @@ -176,19 +221,19 @@ public class WebURIStat { } public int getRunningCount() { - return this.runningCount.get(); + return this.runningCount; } public long getConcurrentMax() { - return concurrentMax.get(); + return concurrentMax; } public long getRequestCount() { - return requestCount.get(); + return requestCount; } public long getRequestTimeNano() { - return requestTimeNano.get(); + return requestTimeNano; } public long getRequestTimeMillis() { @@ -196,47 +241,47 @@ public class WebURIStat { } public void addJdbcFetchRowCount(long delta) { - this.jdbcFetchRowCount.addAndGet(delta); + jdbcFetchRowCountUpdater.addAndGet(this, delta); } public long getJdbcFetchRowCount() { - return jdbcFetchRowCount.get(); + return jdbcFetchRowCount; } public long getJdbcFetchRowPeak() { - return jdbcFetchRowPeak.get(); + return jdbcFetchRowPeak; } public void addJdbcUpdateCount(long updateCount) { - this.jdbcUpdateCount.addAndGet(updateCount); + jdbcUpdateCountUpdater.addAndGet(this, updateCount); } public long getJdbcUpdateCount() { - return jdbcUpdateCount.get(); + return jdbcUpdateCount; } public long getJdbcUpdatePeak() { - return jdbcUpdatePeak.get(); + return jdbcUpdatePeak; } public void incrementJdbcExecuteCount() { - jdbcExecuteCount.incrementAndGet(); + jdbcExecuteCountUpdater.incrementAndGet(this); } public void addJdbcExecuteCount(long executeCount) { - jdbcExecuteCount.addAndGet(executeCount); + jdbcExecuteCountUpdater.addAndGet(this, executeCount); } public long getJdbcExecuteCount() { - return jdbcExecuteCount.get(); + return jdbcExecuteCount; } - public AtomicLong getJdbcExecuteErrorCount() { + public long getJdbcExecuteErrorCount() { return jdbcExecuteErrorCount; } public long getJdbcExecutePeak() { - return jdbcExecutePeak.get(); + return jdbcExecutePeak; } public long getJdbcExecuteTimeMillis() { @@ -244,23 +289,23 @@ public class WebURIStat { } public long getJdbcExecuteTimeNano() { - return jdbcExecuteTimeNano.get(); + return jdbcExecuteTimeNano; } public void incrementJdbcCommitCount() { - jdbcCommitCount.incrementAndGet(); + jdbcCommitCountUpdater.incrementAndGet(this); } public long getJdbcCommitCount() { - return jdbcCommitCount.get(); + return jdbcCommitCount; } public void incrementJdbcRollbackCount() { - jdbcRollbackCount.incrementAndGet(); + jdbcRollbackCountUpdater.incrementAndGet(this); } public long getJdbcRollbackCount() { - return jdbcRollbackCount.get(); + return jdbcRollbackCount; } public void setLastAccessTimeMillis(long lastAccessTimeMillis) { @@ -280,50 +325,56 @@ public class WebURIStat { } public long getErrorCount() { - return errorCount.get(); + return errorCount; } public long getJdbcPoolConnectionOpenCount() { - return jdbcPoolConnectionOpenCount.get(); + return jdbcPoolConnectionOpenCount; } public void addJdbcPoolConnectionOpenCount(long delta) { - jdbcPoolConnectionOpenCount.addAndGet(delta); + jdbcPoolConnectionOpenCountUpdater.addAndGet(this, delta); } public void incrementJdbcPoolConnectionOpenCount() { - jdbcPoolConnectionOpenCount.incrementAndGet(); + jdbcPoolConnectionOpenCountUpdater.incrementAndGet(this); } public long getJdbcPoolConnectionCloseCount() { - return jdbcPoolConnectionCloseCount.get(); + return jdbcPoolConnectionCloseCount; } public void addJdbcPoolConnectionCloseCount(long delta) { - jdbcPoolConnectionCloseCount.addAndGet(delta); + jdbcPoolConnectionCloseCountUpdater.addAndGet(this, delta); } public void incrementJdbcPoolConnectionCloseCount() { - jdbcPoolConnectionCloseCount.incrementAndGet(); + jdbcPoolConnectionCloseCountUpdater.incrementAndGet(this); } public long getJdbcResultSetOpenCount() { - return jdbcResultSetOpenCount.get(); + return jdbcResultSetOpenCount; } public void addJdbcResultSetOpenCount(long delta) { - jdbcResultSetOpenCount.addAndGet(delta); + jdbcResultSetOpenCountUpdater.addAndGet(this, delta); } public long getJdbcResultSetCloseCount() { - return jdbcResultSetCloseCount.get(); + return jdbcResultSetCloseCount; } public void addJdbcResultSetCloseCount(long delta) { - jdbcResultSetCloseCount.addAndGet(delta); + jdbcResultSetCloseCountUpdater.addAndGet(this, delta); } public ProfileStat getProfiletat() { + if (profiletat != null) { + return profiletat; + } + + profiletatUpdater.compareAndSet(this, null, new ProfileStat()); + return profiletat; }