diff --git a/benchmarks/src/main/java/io/prometheus/metrics/benchmarks/HistogramBenchmark.java b/benchmarks/src/main/java/io/prometheus/metrics/benchmarks/HistogramBenchmark.java
index 41b7097db..50cba01a2 100644
--- a/benchmarks/src/main/java/io/prometheus/metrics/benchmarks/HistogramBenchmark.java
+++ b/benchmarks/src/main/java/io/prometheus/metrics/benchmarks/HistogramBenchmark.java
@@ -10,9 +10,12 @@
 import io.opentelemetry.sdk.resources.Resource;
 import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader;
 import io.prometheus.metrics.core.metrics.Histogram;
+import io.prometheus.metrics.model.snapshots.MetricSnapshot;
 import java.util.Arrays;
 import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.Level;
 import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.Threads;
 
@@ -57,6 +60,24 @@ public PrometheusClassicHistogramPerThread() {
     }
   }
 
+  @State(Scope.Benchmark)
+  public static class PrometheusClassicHistogramAfterThreadChurn {
+
+    final Histogram noLabels = Histogram.builder().name("test").help("help").classicOnly().build();
+
+    @Setup(Level.Invocation)
+    public void createShortLivedRecorders() throws InterruptedException {
+      Thread[] recorders = new Thread[1_000];
+      for (int i = 0; i < 1_000; i++) {
+        recorders[i] = new Thread(() -> noLabels.observe(1.0));
+        recorders[i].start();
+      }
+      for (Thread recorder : recorders) {
+        recorder.join();
+      }
+    }
+  }
+
   @State(Scope.Benchmark)
   public static class PrometheusNativeHistogram {
 
@@ -173,6 +194,18 @@ public Histogram prometheusClassicPerThread(
     return histogram.noLabels;
   }
 
+  @Benchmark
+  public long prometheusClassicGetCountAfterThreadChurn(
+      PrometheusClassicHistogramAfterThreadChurn histogram) {
+    return histogram.noLabels.getCount();
+  }
+
+  @Benchmark
+  public MetricSnapshot prometheusClassicCollectAfterThreadChurn(
+      PrometheusClassicHistogramAfterThreadChurn histogram) {
+    return histogram.noLabels.collect();
+  }
+
   @Benchmark
   @Threads(4)
   public Histogram prometheusNative(
diff --git a/docs/apidiffs/current_vs_latest/prometheus-metrics-core.txt b/docs/apidiffs/current_vs_latest/prometheus-metrics-core.txt
index ffb4a1d52..136f7f6f1 100644
--- a/docs/apidiffs/current_vs_latest/prometheus-metrics-core.txt
+++ b/docs/apidiffs/current_vs_latest/prometheus-metrics-core.txt
@@ -1,4 +1,6 @@
 Comparing source compatibility of prometheus-metrics-core-1.8.1-SNAPSHOT.jar against prometheus-metrics-core-1.8.0.jar
 ***  MODIFIED CLASS: PUBLIC io.prometheus.metrics.core.exemplars.ExemplarSampler  (not serializable)
 	===  CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+***  MODIFIED CLASS: PUBLIC io.prometheus.metrics.core.metrics.Histogram$DataPoint  (not serializable)
+	===  CLASS FILE FORMAT VERSION: 52.0 <- 52.0
 
diff --git a/pom.xml b/pom.xml
index 5cebbcb0b..ec065b245 100644
--- a/pom.xml
+++ b/pom.xml
@@ -42,6 +42,7 @@
     <module>prometheus-metrics-annotations</module>
     <module>prometheus-metrics-bom</module>
     <module>prometheus-metrics-core</module>
+    <module>prometheus-metrics-jcstress</module>
     <module>prometheus-metrics-config</module>
     <module>prometheus-metrics-model</module>
     <module>prometheus-metrics-tracer</module>
diff --git a/prometheus-metrics-bom/pom.xml b/prometheus-metrics-bom/pom.xml
index c2c9935f7..ff04d1342 100644
--- a/prometheus-metrics-bom/pom.xml
+++ b/prometheus-metrics-bom/pom.xml
@@ -114,6 +114,11 @@
         <artifactId>prometheus-metrics-instrumentation-jvm</artifactId>
         <version>${project.version}</version>
       </dependency>
+      <dependency>
+        <groupId>io.prometheus</groupId>
+        <artifactId>prometheus-metrics-jcstress</artifactId>
+        <version>${project.version}</version>
+      </dependency>
       <dependency>
         <groupId>io.prometheus</groupId>
         <artifactId>prometheus-metrics-model</artifactId>
diff --git a/prometheus-metrics-core/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulator.java b/prometheus-metrics-core/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulator.java
new file mode 100644
index 000000000..6f460ca33
--- /dev/null
+++ b/prometheus-metrics-core/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulator.java
@@ -0,0 +1,158 @@
+package io.prometheus.metrics.core.metrics;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Experimental accumulator for classic-only histogram data points.
+ *
+ * <p>Each recording thread owns a cell with two buffers. A snapshot advances the global epoch and
+ * drains inactive buffers that are not being written. It does not wait for a paused recorder;
+ * recording threads therefore never contend on a shared monitor or stall a scrape.
+ *
+ * <p>Cells remain registered until both buffers have been collected, after which they can be
+ * reclaimed and re-registered if their recording thread is reused. A cell is static and does not
+ * reference its owning accumulator, so a thread-local value cannot retain a removed or cleared data
+ * point.
+ */
+@SuppressWarnings("ThreadLocalUsage")
+final class ClassicOnlyAccumulator {
+
+  private static final long NOT_WRITING = -1;
+
+  private final int bucketCount;
+  private final AtomicLong epoch = new AtomicLong();
+  private final Set<Cell> cells = ConcurrentHashMap.newKeySet();
+  private final ThreadLocal<Cell> threadCell =
+      new ThreadLocal<Cell>() {
+        @Override
+        protected Cell initialValue() {
+          return new Cell(bucketCount);
+        }
+      };
+
+  // Accessed only while holding this accumulator's monitor.
+  private final long[] collectedBuckets;
+  private long collectedCount;
+  private double collectedSum;
+
+  ClassicOnlyAccumulator(int bucketCount) {
+    this.bucketCount = bucketCount;
+    this.collectedBuckets = new long[bucketCount];
+  }
+
+  void observe(int bucket, double value) {
+    Cell cell = threadCell.get();
+    while (true) {
+      // Cells are removed once both buffers are empty. A thread-local may outlive that removal, so
+      // re-register it before every recording attempt.
+      if (!cell.registered.get() || !cells.contains(cell)) {
+        if (cell.registered.compareAndSet(false, true) || !cells.contains(cell)) {
+          cells.add(cell);
+        }
+      }
+      long observedEpoch = epoch.get();
+      cell.writingEpoch = observedEpoch;
+      // The registration check closes the race with snapshot's empty-cell reclamation. If a
+      // snapshot removed this cell after the first check, do not write into an unregistered cell.
+      if (!cell.registered.get() || epoch.get() != observedEpoch) {
+        cell.writingEpoch = NOT_WRITING;
+        continue;
+      }
+      try {
+        CellBuffer buffer = cell.buffers[(int) (observedEpoch & 1)];
+        buffer.buckets[bucket]++;
+        buffer.sum += value;
+        buffer.count++;
+        return;
+      } finally {
+        // Publishes all plain writes above to a snapshot observing writingEpoch.
+        cell.writingEpoch = NOT_WRITING;
+      }
+    }
+  }
+
+  @SuppressWarnings("ModifyCollectionInEnhancedForLoop")
+  synchronized Snapshot snapshot() {
+    // A snapshot is intentionally allowed to be stale for a cell whose recorder is paused. Do not
+    // wait here: this keeps collect(), getCount(), and getSum() bounded by the registered-cell and
+    // bucket counts, independent of writer stalls, while a subsequent snapshot includes the
+    // delayed observation after the recorder publishes NOT_WRITING.
+    long inactiveEpoch = epoch.getAndIncrement();
+    int inactiveBuffer = (int) (inactiveEpoch & 1);
+
+    for (Cell cell : cells) {
+      if (!canDrainInactiveBuffer(cell, inactiveBuffer)) {
+        // The writer may be paused indefinitely. Leave this buffer untouched; a later snapshot
+        // will collect it after the writer has published NOT_WRITING.
+        continue;
+      }
+      CellBuffer buffer = cell.buffers[inactiveBuffer];
+      for (int i = 0; i < bucketCount; i++) {
+        collectedBuckets[i] += buffer.buckets[i];
+        buffer.buckets[i] = 0;
+      }
+      collectedCount += buffer.count;
+      collectedSum += buffer.sum;
+      buffer.count = 0;
+      buffer.sum = 0;
+
+      // Reclaim cells from short-lived recording threads once their observations have been
+      // collected. The registration check in observe makes this safe if the thread is reused.
+      if (cell.writingEpoch == NOT_WRITING
+          && isEmpty(cell.buffers[0])
+          && isEmpty(cell.buffers[1])
+          && cell.registered.compareAndSet(true, false)) {
+        cells.remove(cell);
+      }
+    }
+
+    return new Snapshot(collectedBuckets.clone(), collectedCount, collectedSum);
+  }
+
+  private static boolean canDrainInactiveBuffer(Cell cell, int inactiveBuffer) {
+    long writingEpoch = cell.writingEpoch;
+    // An old writer can still be in the same parity after a pair of epoch flips. It is not enough
+    // to compare with the current epoch: draining while that writer is active would race with its
+    // plain bucket writes.
+    return writingEpoch == NOT_WRITING || (writingEpoch & 1) != inactiveBuffer;
+  }
+
+  private static boolean isEmpty(CellBuffer buffer) {
+    return buffer.count == 0;
+  }
+
+  private static final class Cell {
+    private final CellBuffer[] buffers;
+    private volatile long writingEpoch = NOT_WRITING;
+    private final AtomicBoolean registered = new AtomicBoolean();
+
+    private Cell(int bucketCount) {
+      buffers = new CellBuffer[] {new CellBuffer(bucketCount), new CellBuffer(bucketCount)};
+    }
+  }
+
+  private static final class CellBuffer {
+    private final long[] buckets;
+    private long count;
+    private double sum;
+
+    private CellBuffer(int bucketCount) {
+      buckets = new long[bucketCount];
+    }
+  }
+
+  static final class Snapshot {
+    final long[] buckets;
+    final long count;
+    final double sum;
+
+    private Snapshot(long[] buckets, long count, double sum) {
+      this.buckets = buckets;
+      this.count = count;
+      this.sum = sum;
+    }
+  }
+}
diff --git a/prometheus-metrics-core/src/main/java/io/prometheus/metrics/core/metrics/Histogram.java b/prometheus-metrics-core/src/main/java/io/prometheus/metrics/core/metrics/Histogram.java
index c4bb1f5fe..c47ff6083 100644
--- a/prometheus-metrics-core/src/main/java/io/prometheus/metrics/core/metrics/Histogram.java
+++ b/prometheus-metrics-core/src/main/java/io/prometheus/metrics/core/metrics/Histogram.java
@@ -205,6 +205,7 @@ public class DataPoint implements DistributionDataPoint {
     private final LongAdder nativeZeroCount = new LongAdder();
     private final LongAdder count = new LongAdder();
     private final DoubleAdder sum = new DoubleAdder();
+    @Nullable private final ClassicOnlyAccumulator classicOnlyAccumulator;
     private volatile int nativeSchema =
         nativeInitialSchema; // integer in [-4, 8] or CLASSIC_HISTOGRAM
     private volatile double nativeZeroThreshold = Histogram.this.nativeMinZeroThreshold;
@@ -223,16 +224,28 @@ private DataPoint() {
       for (int i = 0; i < classicUpperBounds.length; i++) {
         classicBuckets[i] = new LongAdder();
       }
+      classicOnlyAccumulator =
+          isClassicOnly() ? new ClassicOnlyAccumulator(classicUpperBounds.length) : null;
       maybeScheduleNextReset();
     }
 
     @Override
     public double getSum() {
+      if (classicOnlyAccumulator != null) {
+        // A paused recorder may make this exact value temporarily stale. A later snapshot, after
+        // the intervening buffer rotation, retries its buffer rather than blocking the scrape.
+        return classicOnlyAccumulator.snapshot().sum;
+      }
       return sum.sum();
     }
 
     @Override
     public long getCount() {
+      if (classicOnlyAccumulator != null) {
+        // A paused recorder may make this exact value temporarily stale. A later snapshot, after
+        // the intervening buffer rotation, retries its buffer rather than blocking the scrape.
+        return classicOnlyAccumulator.snapshot().count;
+      }
       return count.sum();
     }
 
@@ -242,7 +255,9 @@ public void observe(double value) {
         // See https://github.com/prometheus/client_golang/issues/1275 on ignoring NaN observations.
         return;
       }
-      if (!buffer.append(value)) {
+      if (classicOnlyAccumulator != null) {
+        classicOnlyAccumulator.observe(findClassicBucket(value), value);
+      } else if (!buffer.append(value)) {
         doObserve(value, false);
       }
       if (exemplarSampler != null) {
@@ -256,7 +271,9 @@ public void observeWithExemplar(double value, Labels labels) {
         // See https://github.com/prometheus/client_golang/issues/1275 on ignoring NaN observations.
         return;
       }
-      if (!buffer.append(value)) {
+      if (classicOnlyAccumulator != null) {
+        classicOnlyAccumulator.observe(findClassicBucket(value), value);
+      } else if (!buffer.append(value)) {
         doObserve(value, false);
       }
       if (exemplarSampler != null) {
@@ -266,12 +283,8 @@ public void observeWithExemplar(double value, Labels labels) {
 
     private void doObserve(double value, boolean fromBuffer) {
       // classicUpperBounds is an empty array if this is a native histogram only.
-      for (int i = 0; i < classicUpperBounds.length; ++i) {
-        // The last bucket is +Inf, so we always increment.
-        if (value <= classicUpperBounds[i]) {
-          classicBuckets[i].add(1);
-          break;
-        }
+      if (classicUpperBounds.length > 0) {
+        classicBuckets[findClassicBucket(value)].add(1);
       }
       boolean nativeBucketCreated = false;
       if (Histogram.this.nativeInitialSchema != CLASSIC_HISTOGRAM) {
@@ -301,6 +314,17 @@ private void doObserve(double value, boolean fromBuffer) {
 
     private HistogramSnapshot.HistogramDataPointSnapshot collect(Labels labels) {
       Exemplars exemplars = exemplarSampler != null ? exemplarSampler.collect() : Exemplars.EMPTY;
+      if (classicOnlyAccumulator != null) {
+        // collect() is intentionally allowed to return a stale snapshot for a paused recorder; a
+        // later collection, after the intervening buffer rotation, retries its buffer.
+        ClassicOnlyAccumulator.Snapshot snapshot = classicOnlyAccumulator.snapshot();
+        return new HistogramSnapshot.HistogramDataPointSnapshot(
+            ClassicHistogramBuckets.of(classicUpperBounds, snapshot.buckets),
+            snapshot.sum,
+            labels,
+            exemplars,
+            createdTimeMillis);
+      }
       return buffer.run(
           expectedCount -> count.sum() == expectedCount,
           () -> {
@@ -342,6 +366,20 @@ private HistogramSnapshot.HistogramDataPointSnapshot collect(Labels labels) {
           v -> doObserve(v, true));
     }
 
+    private boolean isClassicOnly() {
+      return Histogram.this.nativeInitialSchema == CLASSIC_HISTOGRAM;
+    }
+
+    private int findClassicBucket(double value) {
+      for (int i = 0; i < classicUpperBounds.length; ++i) {
+        // The last bucket is +Inf, so we always return from this loop.
+        if (value <= classicUpperBounds[i]) {
+          return i;
+        }
+      }
+      throw new IllegalStateException("Classic histogram is missing the +Inf bucket.");
+    }
+
     private boolean addToNativeBucket(double value, ConcurrentHashMap<Integer, LongAdder> buckets) {
       boolean newBucketCreated = false;
       int bucketIndex;
diff --git a/prometheus-metrics-core/src/test/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorTest.java b/prometheus-metrics-core/src/test/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorTest.java
new file mode 100644
index 000000000..c9bd5e483
--- /dev/null
+++ b/prometheus-metrics-core/src/test/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorTest.java
@@ -0,0 +1,161 @@
+package io.prometheus.metrics.core.metrics;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
+
+import java.lang.reflect.Field;
+import java.time.Duration;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+
+class ClassicOnlyAccumulatorTest {
+
+  @Test
+  void stalledWriterDoesNotBlockSnapshotAndIsCollectedLater() throws Exception {
+    ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(2);
+    accumulator.observe(0, 1.0);
+
+    Object cell = onlyCell(accumulator);
+    Field writingEpoch = cell.getClass().getDeclaredField("writingEpoch");
+    writingEpoch.setAccessible(true);
+    writingEpoch.setLong(cell, 0);
+
+    ClassicOnlyAccumulator.Snapshot skipped =
+        assertTimeoutPreemptively(Duration.ofMillis(500), accumulator::snapshot);
+    assertThat(skipped.count).isZero();
+
+    writingEpoch.setLong(cell, -1);
+    // The first post-release snapshot flips to the other buffer. The following one revisits the
+    // delayed writer's buffer and must retain its observation.
+    accumulator.snapshot();
+    ClassicOnlyAccumulator.Snapshot collected = accumulator.snapshot();
+    assertThat(collected.count).isEqualTo(1);
+    assertThat(collected.sum).isEqualTo(1.0);
+  }
+
+  @Test
+  void stalledCellDoesNotPreventHealthyCellsFromBeingCollected() throws Exception {
+    ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(1);
+    accumulator.observe(0, 1.0);
+    for (int i = 0; i < 4; i++) {
+      Thread recorder = new Thread(() -> accumulator.observe(0, 1.0));
+      recorder.start();
+      recorder.join();
+    }
+
+    Object stalledCell = onlyCell(accumulator);
+    Field writingEpoch = stalledCell.getClass().getDeclaredField("writingEpoch");
+    writingEpoch.setAccessible(true);
+    writingEpoch.setLong(stalledCell, 0);
+
+    ClassicOnlyAccumulator.Snapshot first = accumulator.snapshot();
+    // The four healthy cells are drained even though the first cell consumes its own wait budget.
+    assertThat(first.count).isEqualTo(4);
+
+    writingEpoch.setLong(stalledCell, -1);
+    accumulator.snapshot();
+    ClassicOnlyAccumulator.Snapshot finalSnapshot = accumulator.snapshot();
+    assertThat(finalSnapshot.count).isEqualTo(5);
+  }
+
+  @Test
+  void activeWriterCanResumeAfterAStaleSnapshot() throws Exception {
+    ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(1);
+    accumulator.observe(0, 1.0);
+    Object cell = onlyCell(accumulator);
+    Field writingEpoch = cell.getClass().getDeclaredField("writingEpoch");
+    writingEpoch.setAccessible(true);
+    CountDownLatch entered = new CountDownLatch(1);
+    CountDownLatch release = new CountDownLatch(1);
+    Thread writer =
+        new Thread(
+            () -> {
+              try {
+                writingEpoch.setLong(cell, 0);
+                entered.countDown();
+                release.await();
+                writingEpoch.setLong(cell, -1);
+              } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+              } catch (IllegalAccessException e) {
+                throw new AssertionError(e);
+              }
+            });
+    writer.start();
+    entered.await();
+
+    ClassicOnlyAccumulator.Snapshot stale = accumulator.snapshot();
+    assertThat(stale.count).isZero();
+    release.countDown();
+    writer.join();
+    accumulator.snapshot();
+    ClassicOnlyAccumulator.Snapshot resumed = accumulator.snapshot();
+    assertThat(resumed.count).isEqualTo(1);
+  }
+
+  @Test
+  void emptyCellsAreReclaimedAndCanBeReused() throws Exception {
+    ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(1);
+    accumulator.observe(0, 1.0);
+    Set<?> cells = cells(accumulator);
+    assertThat(cells).hasSize(1);
+
+    accumulator.snapshot();
+    assertThat(cells).isEmpty();
+
+    accumulator.observe(0, 2.0);
+    assertThat(cells).hasSize(1);
+    accumulator.snapshot();
+    assertThat(cells).isEmpty();
+  }
+
+  @Test
+  void concurrentWritersAndSnapshotsPreserveJmmVisibility() throws Exception {
+    ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(3);
+    int writers = 8;
+    int observationsPerWriter = 10_000;
+    CountDownLatch start = new CountDownLatch(1);
+    ExecutorService executor = Executors.newFixedThreadPool(writers);
+    try {
+      for (int writer = 0; writer < writers; writer++) {
+        int bucket = writer % 3;
+        executor.submit(
+            () -> {
+              start.await();
+              for (int i = 0; i < observationsPerWriter; i++) {
+                accumulator.observe(bucket, bucket + 1.0);
+              }
+              return null;
+            });
+      }
+      start.countDown();
+      executor.shutdown();
+      while (!executor.awaitTermination(10, TimeUnit.MILLISECONDS)) {
+        accumulator.snapshot();
+      }
+    } finally {
+      executor.shutdownNow();
+    }
+
+    ClassicOnlyAccumulator.Snapshot snapshot = accumulator.snapshot();
+    snapshot = accumulator.snapshot();
+    assertThat(snapshot.count).isEqualTo(writers * observationsPerWriter);
+    assertThat(snapshot.buckets).containsExactly(30_000, 30_000, 20_000);
+    assertThat(snapshot.sum).isEqualTo(150_000.0);
+  }
+
+  private static Object onlyCell(ClassicOnlyAccumulator accumulator) throws Exception {
+    return cells(accumulator).iterator().next();
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Set<Object> cells(ClassicOnlyAccumulator accumulator) throws Exception {
+    Field cells = ClassicOnlyAccumulator.class.getDeclaredField("cells");
+    cells.setAccessible(true);
+    return (Set<Object>) cells.get(accumulator);
+  }
+}
diff --git a/prometheus-metrics-core/src/test/java/io/prometheus/metrics/core/metrics/HistogramTest.java b/prometheus-metrics-core/src/test/java/io/prometheus/metrics/core/metrics/HistogramTest.java
index cbfd5fade..127fd6a3e 100644
--- a/prometheus-metrics-core/src/test/java/io/prometheus/metrics/core/metrics/HistogramTest.java
+++ b/prometheus-metrics-core/src/test/java/io/prometheus/metrics/core/metrics/HistogramTest.java
@@ -41,6 +41,7 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.LongAdder;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.AfterEach;
@@ -1598,6 +1599,117 @@ void testObserveMultithreaded()
     assertThat(executor.awaitTermination(5, TimeUnit.SECONDS)).isTrue();
   }
 
+  @Test
+  void testClassicOnlyCollectWhileObserversAreRunning() throws Exception {
+    Histogram histogram = Histogram.builder().name("test").classicOnly().build();
+    DistributionDataPoint dataPoint = histogram.labelValues();
+    int observerCount = 8;
+    int observationsPerThread = 25_000;
+    ExecutorService executor = Executors.newFixedThreadPool(observerCount + 1);
+    CountDownLatch ready = new CountDownLatch(observerCount);
+    CountDownLatch start = new CountDownLatch(1);
+    AtomicBoolean observersFinished = new AtomicBoolean();
+    List<Future<?>> observers = new ArrayList<>();
+
+    for (int i = 0; i < observerCount; i++) {
+      observers.add(
+          executor.submit(
+              () -> {
+                ready.countDown();
+                start.await();
+                for (int observation = 0; observation < observationsPerThread; observation++) {
+                  dataPoint.observe(1.25);
+                }
+                return null;
+              }));
+    }
+
+    Future<?> collector =
+        executor.submit(
+            () -> {
+              long previousCount = 0;
+              start.await();
+              while (!observersFinished.get()) {
+                HistogramSnapshot.HistogramDataPointSnapshot snapshot =
+                    histogram.collect().getDataPoints().get(0);
+                assertClassicOnlySnapshotIsCoherent(snapshot, previousCount);
+                previousCount = snapshot.getCount();
+              }
+              return null;
+            });
+
+    assertThat(ready.await(5, TimeUnit.SECONDS)).isTrue();
+    start.countDown();
+    for (Future<?> observer : observers) {
+      observer.get(10, TimeUnit.SECONDS);
+    }
+    observersFinished.set(true);
+    collector.get(10, TimeUnit.SECONDS);
+
+    HistogramSnapshot.HistogramDataPointSnapshot snapshot =
+        histogram.collect().getDataPoints().get(0);
+    assertClassicOnlySnapshotIsCoherent(snapshot, observerCount * observationsPerThread);
+    assertThat(dataPoint.getCount()).isEqualTo(observerCount * observationsPerThread);
+    assertThat(dataPoint.getSum())
+        .isCloseTo(observerCount * observationsPerThread * 1.25, offset(0.000_001));
+
+    executor.shutdown();
+    assertThat(executor.awaitTermination(5, TimeUnit.SECONDS)).isTrue();
+  }
+
+  @Test
+  void testClassicOnlyRetainsShortLivedThreadCellsAndClearCreatesFreshDataPoint() throws Exception {
+    Histogram histogram =
+        Histogram.builder().name("test").classicOnly().labelNames("status").build();
+    DistributionDataPoint oldDataPoint = histogram.labelValues("200");
+    int threadCount = 100;
+    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+    CountDownLatch start = new CountDownLatch(1);
+    List<Future<?>> observations = new ArrayList<>();
+    for (int i = 0; i < threadCount; i++) {
+      observations.add(
+          executor.submit(
+              () -> {
+                start.await();
+                oldDataPoint.observe(2.0);
+                return null;
+              }));
+    }
+    start.countDown();
+    for (Future<?> observation : observations) {
+      observation.get(5, TimeUnit.SECONDS);
+    }
+    executor.shutdown();
+    assertThat(executor.awaitTermination(5, TimeUnit.SECONDS)).isTrue();
+
+    assertThat(oldDataPoint.getCount()).isEqualTo(threadCount);
+    assertThat(oldDataPoint.getSum()).isEqualTo(threadCount * 2.0);
+    assertThat(getBucket(histogram, 2.5, "status", "200").getCount()).isEqualTo(threadCount);
+
+    histogram.clear();
+    DistributionDataPoint newDataPoint = histogram.labelValues("200");
+    assertThat(newDataPoint).isNotSameAs(oldDataPoint);
+    assertThat(newDataPoint.getCount()).isZero();
+    assertThat(newDataPoint.getSum()).isZero();
+
+    newDataPoint.observe(3.0);
+    assertThat(newDataPoint.getCount()).isOne();
+    assertThat(newDataPoint.getSum()).isEqualTo(3.0);
+    assertThat(oldDataPoint.getCount()).isEqualTo(threadCount);
+    assertThat(oldDataPoint.getSum()).isEqualTo(threadCount * 2.0);
+  }
+
+  private static void assertClassicOnlySnapshotIsCoherent(
+      HistogramSnapshot.HistogramDataPointSnapshot snapshot, long minimumCount) {
+    assertThat(snapshot.getCount()).isGreaterThanOrEqualTo(minimumCount);
+    assertThat(snapshot.getSum()).isCloseTo(snapshot.getCount() * 1.25, offset(0.000_001));
+    long bucketTotal = 0;
+    for (ClassicHistogramBucket bucket : snapshot.getClassicBuckets()) {
+      bucketTotal += bucket.getCount();
+    }
+    assertThat(bucketTotal).isEqualTo(snapshot.getCount());
+  }
+
   @Test
   void testNativeResetDuration() {
     // Test that nativeResetDuration can be configured without error and the histogram
diff --git a/prometheus-metrics-jcstress/README.md b/prometheus-metrics-jcstress/README.md
new file mode 100644
index 000000000..0a34d803b
--- /dev/null
+++ b/prometheus-metrics-jcstress/README.md
@@ -0,0 +1,18 @@
+# JCStress tests
+
+This module contains the JCStress coverage for the concurrent metric
+accumulators. It is intentionally separate from the regular unit-test
+suite because JCStress uses an isolated, generated test harness.
+
+Build the harness and run the accumulator tests with:
+
+```bash
+./mvnw -pl prometheus-metrics-jcstress -am package -DskipTests
+java -jar prometheus-metrics-jcstress/target/jcstress.jar \
+  -t ClassicOnlyAccumulator -iters 10 -f 1
+```
+
+The tests cover epoch publication, delayed writers, cell reclamation and
+re-registration, and eventual observation visibility. A snapshot may be
+intentionally stale while a writer is paused; the tests accept that outcome
+but require the observation to become visible after the writer is released.
diff --git a/prometheus-metrics-jcstress/pom.xml b/prometheus-metrics-jcstress/pom.xml
new file mode 100644
index 000000000..c0b73d5b9
--- /dev/null
+++ b/prometheus-metrics-jcstress/pom.xml
@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>io.prometheus</groupId>
+    <artifactId>client_java</artifactId>
+    <version>1.8.1-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>prometheus-metrics-jcstress</artifactId>
+  <packaging>jar</packaging>
+
+  <name>Prometheus Metrics JCStress Tests</name>
+  <description>JCStress tests for concurrent Prometheus metric implementations</description>
+
+  <properties>
+    <jcstress.version>0.16</jcstress.version>
+    <uberjar.name>jcstress</uberjar.name>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.prometheus</groupId>
+      <artifactId>prometheus-metrics-core</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.openjdk.jcstress</groupId>
+      <artifactId>jcstress-core</artifactId>
+      <version>${jcstress.version}</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.15.0</version>
+        <configuration>
+          <compilerArgs combine.self="override">
+            <arg>-Xlint:all,-serial,-processing,-options</arg>
+            <arg>-Werror</arg>
+            <arg>--should-stop=ifError=FLOW</arg>
+            <arg>-XDcompilePolicy=simple</arg>
+            <arg>-XDaddTypeAnnotationsToSymbol=true</arg>
+          </compilerArgs>
+          <annotationProcessorPaths combine.children="append">
+            <path>
+              <groupId>org.openjdk.jcstress</groupId>
+              <artifactId>jcstress-core</artifactId>
+              <version>${jcstress.version}</version>
+            </path>
+          </annotationProcessorPaths>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.6.2</version>
+        <executions>
+          <execution>
+            <id>jcstress-uberjar</id>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <finalName>${uberjar.name}</finalName>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <mainClass>org.openjdk.jcstress.Main</mainClass>
+                </transformer>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
+                  <resource>META-INF/TestList</resource>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorNoLossTest.java b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorNoLossTest.java
new file mode 100644
index 000000000..9a5796c02
--- /dev/null
+++ b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorNoLossTest.java
@@ -0,0 +1,37 @@
+package io.prometheus.metrics.core.metrics;
+
+import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.Expect;
+import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
+import org.openjdk.jcstress.annotations.State;
+import org.openjdk.jcstress.infra.results.JD_Result;
+
+@JCStressTest
+@Outcome(
+    id = "2, 3.0",
+    expect = Expect.ACCEPTABLE,
+    desc = "Concurrent observations are visible with coherent count and sum.")
+@State
+public class ClassicOnlyAccumulatorNoLossTest {
+  private final ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(1);
+
+  @Actor
+  public void observeOne() {
+    accumulator.observe(0, 1.0);
+  }
+
+  @Actor
+  public void observeTwo() {
+    accumulator.observe(0, 2.0);
+  }
+
+  @Arbiter
+  public void collect(JD_Result result) {
+    accumulator.snapshot();
+    ClassicOnlyAccumulator.Snapshot snapshot = accumulator.snapshot();
+    result.r1 = snapshot.count;
+    result.r2 = snapshot.sum;
+  }
+}
diff --git a/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorPublicationTest.java b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorPublicationTest.java
new file mode 100644
index 000000000..ea3145106
--- /dev/null
+++ b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorPublicationTest.java
@@ -0,0 +1,40 @@
+package io.prometheus.metrics.core.metrics;
+
+import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.Expect;
+import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
+import org.openjdk.jcstress.annotations.State;
+import org.openjdk.jcstress.infra.results.II_Result;
+
+@JCStressTest
+@Outcome(
+    id = "1, 1",
+    expect = Expect.ACCEPTABLE,
+    desc = "A completed observation is published to a subsequent snapshot.")
+@State
+public class ClassicOnlyAccumulatorPublicationTest {
+  private final ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(1);
+  private volatile boolean observed;
+
+  @Actor
+  public void observe() {
+    accumulator.observe(0, 1.0);
+    observed = true;
+  }
+
+  @Actor
+  public void snapshot(II_Result result) {
+    while (!observed) {
+      Thread.yield();
+    }
+    result.r1 = accumulator.snapshot().count > 0 ? 1 : 0;
+  }
+
+  @Arbiter
+  public void finalSnapshot(II_Result result) {
+    accumulator.snapshot();
+    result.r2 = accumulator.snapshot().count > 0 ? 1 : 0;
+  }
+}
diff --git a/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorReRegistrationTest.java b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorReRegistrationTest.java
new file mode 100644
index 000000000..ab54d7d4e
--- /dev/null
+++ b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorReRegistrationTest.java
@@ -0,0 +1,40 @@
+package io.prometheus.metrics.core.metrics;
+
+import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.Expect;
+import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
+import org.openjdk.jcstress.annotations.State;
+import org.openjdk.jcstress.infra.results.J_Result;
+
+@JCStressTest
+@Outcome(
+    id = "2",
+    expect = Expect.ACCEPTABLE,
+    desc = "A reclaimed thread cell is re-registered without losing observations.")
+@State
+public class ClassicOnlyAccumulatorReRegistrationTest {
+  private final ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(1);
+
+  @Actor
+  public void observeReclaimAndReuse() {
+    accumulator.observe(0, 1.0);
+    accumulator.snapshot();
+    accumulator.observe(0, 2.0);
+  }
+
+  @Actor
+  public void concurrentSnapshots() {
+    // Keep a second actor so the test still runs through JCStress's actor/arbiter protocol. The
+    // reclamation and re-registration happen on one recording thread; concurrent snapshots are
+    // covered by the stalled-writer and no-loss tests.
+  }
+
+  @Arbiter
+  public void collect(J_Result result) {
+    accumulator.snapshot();
+    accumulator.snapshot();
+    result.r1 = accumulator.snapshot().count;
+  }
+}
diff --git a/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorStalledWriterTest.java b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorStalledWriterTest.java
new file mode 100644
index 000000000..e7ac86e52
--- /dev/null
+++ b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorStalledWriterTest.java
@@ -0,0 +1,51 @@
+package io.prometheus.metrics.core.metrics;
+
+import javax.annotation.Nullable;
+import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.Expect;
+import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
+import org.openjdk.jcstress.annotations.State;
+import org.openjdk.jcstress.infra.results.II_Result;
+
+@JCStressTest
+@Outcome(
+    id = "0, 1",
+    expect = Expect.ACCEPTABLE,
+    desc = "A paused writer is skipped and collected after it resumes.")
+@State
+public class ClassicOnlyAccumulatorStalledWriterTest {
+  private final ClassicOnlyAccumulator accumulator = new ClassicOnlyAccumulator(1);
+  private volatile @Nullable Object stalledCell;
+  private volatile boolean cellReady;
+
+  @Actor
+  public void pauseWriter() {
+    stalledCell = ClassicOnlyAccumulatorStressSupport.createStalledCell(accumulator);
+    cellReady = true;
+  }
+
+  @Actor
+  public void snapshot(II_Result result) {
+    while (!cellReady) {
+      Thread.yield();
+    }
+    result.r1 = accumulator.snapshot().count > 0 ? 1 : 0;
+  }
+
+  @Arbiter
+  public void resumeAndCollect(II_Result result) {
+    Object cell = stalledCell;
+    if (cell == null) {
+      throw new AssertionError("Writer did not publish its cell");
+    }
+    ClassicOnlyAccumulatorStressSupport.releaseStalledCell(cell);
+    // The observing actor may have advanced the epoch before creating the stalled cell.
+    // Four flips cover both buffer parities and leave the result independent of that race.
+    accumulator.snapshot();
+    accumulator.snapshot();
+    accumulator.snapshot();
+    result.r2 = accumulator.snapshot().count > 0 ? 1 : 0;
+  }
+}
diff --git a/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorStressSupport.java b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorStressSupport.java
new file mode 100644
index 000000000..40e8b780b
--- /dev/null
+++ b/prometheus-metrics-jcstress/src/main/java/io/prometheus/metrics/core/metrics/ClassicOnlyAccumulatorStressSupport.java
@@ -0,0 +1,60 @@
+package io.prometheus.metrics.core.metrics;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+final class ClassicOnlyAccumulatorStressSupport {
+  private static final Field CELLS = field(ClassicOnlyAccumulator.class, "cells");
+  private static final Field EPOCH = field(ClassicOnlyAccumulator.class, "epoch");
+  private static final Field THREAD_CELL = field(ClassicOnlyAccumulator.class, "threadCell");
+  private static final Method SET_ADD = method(Set.class, "add", Object.class);
+
+  private ClassicOnlyAccumulatorStressSupport() {}
+
+  static Object createStalledCell(ClassicOnlyAccumulator accumulator) {
+    try {
+      Object cell = ((ThreadLocal<?>) THREAD_CELL.get(accumulator)).get();
+      SET_ADD.invoke(CELLS.get(accumulator), cell);
+      Field registered = field(cell.getClass(), "registered");
+      ((AtomicBoolean) registered.get(cell)).set(true);
+      long epoch = ((AtomicLong) EPOCH.get(accumulator)).get();
+      field(cell.getClass(), "writingEpoch").setLong(cell, epoch);
+      Object buffer = ((Object[]) field(cell.getClass(), "buffers").get(cell))[(int) (epoch & 1)];
+      ((long[]) field(buffer.getClass(), "buckets").get(buffer))[0] = 1;
+      field(buffer.getClass(), "count").setLong(buffer, 1);
+      field(buffer.getClass(), "sum").setDouble(buffer, 1.0);
+      return cell;
+    } catch (ReflectiveOperationException e) {
+      throw new LinkageError("Unable to model a paused writer", e);
+    }
+  }
+
+  static void releaseStalledCell(Object cell) {
+    try {
+      field(cell.getClass(), "writingEpoch").setLong(cell, -1);
+    } catch (ReflectiveOperationException e) {
+      throw new LinkageError("Unable to resume a paused writer", e);
+    }
+  }
+
+  private static Field field(Class<?> type, String name) {
+    try {
+      Field field = type.getDeclaredField(name);
+      field.setAccessible(true);
+      return field;
+    } catch (ReflectiveOperationException e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+
+  private static Method method(Class<?> type, String name, Class<?>... parameterTypes) {
+    try {
+      return type.getMethod(name, parameterTypes);
+    } catch (ReflectiveOperationException e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+}