replace LongAdder by AtomicLong because LongAdder sometimes can provi…

…de inaccurate sum in case of read happens in parallel with writes

src/main/java/com/github/metricscore/hdr/counter/ResetAtSnapshotCounter.java

@@ -17,7 +17,7 @@
 
 package com.github.metricscore.hdr.counter;
 
-import java.util.concurrent.atomic.LongAdder;
+import java.util.concurrent.atomic.AtomicLong;
 
 /**
  * The counter which reset its state to zero after each invocation of {@link #getSum()}.
@@ -45,17 +45,17 @@
  */
 public class ResetAtSnapshotCounter implements WindowCounter {
 
-    private final LongAdder value = new LongAdder();
+    private final AtomicLong value = new AtomicLong();
 
     @Override
     public void add(long delta) {
-        this.value.add(delta);
+        this.value.addAndGet(delta);
     }
 
     @Override
     synchronized public long getSum() {
-        long sum = value.sum();
-        value.add(-sum);
+        long sum = value.get();
+        value.addAndGet(-sum);
         return sum;
     }
 

src/main/java/com/github/metricscore/hdr/counter/ResetPeriodicallyCounter.java

@@ -21,7 +21,6 @@
 
 import java.time.Duration;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.LongAdder;
 
 /**
  * The counter which reset its state to zero each time when configured interval is elapsed.
@@ -47,7 +46,7 @@
  */
 public class ResetPeriodicallyCounter implements WindowCounter {
 
-    private final LongAdder value = new LongAdder();
+    private final AtomicLong value = new AtomicLong();
     private final long resetIntervalMillis;
     private final Clock clock;
     private final AtomicLong nextResetTimeMillisRef;
@@ -76,12 +75,12 @@ public void add(long delta) {
             long nextResetTimeMillis = nextResetTimeMillisRef.get();
             long currentTimeMillis = clock.getTime();
             if (currentTimeMillis < nextResetTimeMillis) {
-                value.add(delta);
+                value.addAndGet(delta);
                 return;
             }
-            long currentValue = value.sum();
+            long currentValue = value.get();
             if (nextResetTimeMillisRef.compareAndSet(nextResetTimeMillis, Long.MAX_VALUE)) {
-                value.add(delta - currentValue);
+                value.addAndGet(delta - currentValue);
                 nextResetTimeMillisRef.set(currentTimeMillis + resetIntervalMillis);
                 return;
             }
@@ -92,16 +91,16 @@ public void add(long delta) {
     public long getSum() {
         while (true) {
             long nextResetTimeMillis = nextResetTimeMillisRef.get();
-            long currentValue = value.sum();
+            long currentValue = value.get();
             long currentTimeMillis = clock.getTime();
             if (currentTimeMillis < nextResetTimeMillis) {
                 return currentValue;
             }
 
             if (nextResetTimeMillisRef.compareAndSet(nextResetTimeMillis, Long.MAX_VALUE)) {
-                value.add(-currentValue);
+                value.addAndGet(-currentValue);
                 nextResetTimeMillisRef.set(currentTimeMillis + resetIntervalMillis);
-                return value.sum();
+                return value.get();
             }
         }
     }

src/main/java/com/github/metricscore/hdr/counter/SmoothlyDecayingRollingCounter.java

@@ -21,8 +21,8 @@
 import com.github.metricscore.hdr.histogram.util.Printer;
 
 import java.time.Duration;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.concurrent.atomic.LongAdder;
 
 /**
  * The rolling time window counter implementation which resets its state by chunks.
@@ -53,7 +53,7 @@
  * Performance considerations:
  * <ul>
  *     <li>You can consider writing speed as a constant. The write latency does not depend from count of chunk or frequency of chunk rotation.
- *     <li>The writing depends only from level of contention between writers(internally counter implemented across LongAdder).</li>
+ *     <li>The writing depends only from level of contention between writers(internally counter implemented across AtomicLong).</li>
  *     <li>The huge count of chunk leads to the slower calculation of their sum. So precision of sum conflicts with latency of sum. You need to choose meaningful values.
  *     For example 10 chunks will guarantee at least 90% accuracy and ten million reads per second.</li>
  * </ul>
@@ -195,7 +195,7 @@ void add(long delta, long currentTimeMillis) {
                 }
             }
 
-            currentPhase.sum.add(delta);
+            currentPhase.sum.addAndGet(delta);
         }
 
         @Override
@@ -209,11 +209,11 @@ public String toString() {
 
     private final class Phase {
 
-        final LongAdder sum;
+        final AtomicLong sum;
         final long proposedInvalidationTimestamp;
 
         Phase(long proposedInvalidationTimestamp) {
-            this.sum = new LongAdder();
+            this.sum = new AtomicLong();
             this.proposedInvalidationTimestamp = proposedInvalidationTimestamp;
         }
 
@@ -224,7 +224,7 @@ long getSum(long currentTimeMillis) {
                 return 0;
             }
 
-            long sum = this.sum.sum();
+            long sum = this.sum.get();
 
             // if this is oldest chunk then we need to
             long beforeInvalidateMillis = proposedInvalidationTimestamp - currentTimeMillis;