maybe

Author: fandreuz

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/internal/aggregator/DoubleLastValueAggregator.java

@@ -22,8 +22,8 @@
 import io.opentelemetry.sdk.resources.Resource;
 import java.util.Collection;
 import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Supplier;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
@@ -114,8 +114,7 @@ public MetricData toMetricData(
   }
 
   static final class Handle extends AggregatorHandle<DoublePointData, DoubleExemplarData> {
-    @Nullable private static final Double DEFAULT_VALUE = null;
-    private final AtomicReference<Double> current = new AtomicReference<>(DEFAULT_VALUE);
+    private final AtomicDouble current = new AtomicDouble();
 
     // Only used when memoryMode is REUSABLE_DATA
     @Nullable private final MutableDoublePointData reusablePoint;
@@ -136,20 +135,50 @@ protected DoublePointData doAggregateThenMaybeReset(
         Attributes attributes,
         List<DoubleExemplarData> exemplars,
         boolean reset) {
-      Double value = reset ? this.current.getAndSet(DEFAULT_VALUE) : this.current.get();
-      if (reusablePoint != null) {
-        reusablePoint.set(
-            startEpochNanos, epochNanos, attributes, Objects.requireNonNull(value), exemplars);
-        return reusablePoint;
-      } else {
+      double currentDouble = current.getAndReset();
+      if (reusablePoint == null) {
         return ImmutableDoublePointData.create(
-            startEpochNanos, epochNanos, attributes, Objects.requireNonNull(value), exemplars);
+            startEpochNanos, epochNanos, attributes, currentDouble, exemplars);
       }
+      reusablePoint.set(startEpochNanos, epochNanos, attributes, currentDouble, exemplars);
+      return reusablePoint;
     }
 
     @Override
     protected void doRecordDouble(double value) {
       current.set(value);
     }
   }
+
+  private static final class AtomicDouble {
+    private final Lock lock = new ReentrantLock();
+    private long current = 0;
+    private boolean set = false;
+
+    public void set(double value) {
+      long longValue = Double.doubleToLongBits(value);
+      lock.lock();
+      try {
+        current = longValue;
+        set = true;
+      } finally {
+        lock.unlock();
+      }
+    }
+
+    public double getAndReset() {
+      long currentLocal;
+      lock.lock();
+      try {
+        if (!set) {
+          return 0;
+        }
+        currentLocal = current;
+        set = false;
+      } finally {
+        lock.unlock();
+      }
+      return Double.longBitsToDouble(currentLocal);
+    }
+  }
 }