fix: stabilize flaky timer and thread count tests (#1973)

## Summary

- **GaugeTest.testTimer**: `Thread.sleep(12)` can take 100ms+ on CI.
  Assert `> 10ms` instead of `closeTo(12ms, 5ms)`
- **JvmThreadsMetricsTest.testInvalidThreadIds**: background threads
  can start between scrapes. Assert only that UNKNOWN count increased
  by the expected amount, ignore other states

Fixes #1971, fixes #1972

## Test plan

- [x] Both tests pass locally
- [x] `mise run build` passes
- [ ] CI passes

Signed-off-by: Gregor Zeitlinger <gregor.zeitlinger@grafana.com>

Author: zeitlinger

prometheus-metrics-core/src/test/java/io/prometheus/metrics/core/metrics/GaugeTest.java

@@ -87,8 +87,7 @@ public void testTimer() throws InterruptedException {
     try (Timer ignored = noLabels.startTimer()) {
       Thread.sleep(12);
     }
-    assertThat(getValue(noLabels))
-        .isCloseTo(0.012, offset(0.005)); // 5ms delta should be enough so this isn't flaky
+    assertThat(getValue(noLabels)).isGreaterThan(0.01);
   }
 
   @Test

prometheus-metrics-instrumentation-jvm/src/test/java/io/prometheus/metrics/instrumentation/jvm/JvmThreadsMetricsTest.java

@@ -118,11 +118,8 @@ void testInvalidThreadIds() {
     // Number of threads to create with invalid thread ids
     int numberOfInvalidThreadIds = 2;
 
-    Map<String, Double> expected = getCountByState(registry.scrape());
-    expected.compute(
-        "UNKNOWN",
-        (key, oldValue) ->
-            oldValue == null ? numberOfInvalidThreadIds : oldValue + numberOfInvalidThreadIds);
+    Map<String, Double> before = getCountByState(registry.scrape());
+    double unknownBefore = before.getOrDefault("UNKNOWN", 0.0);
 
     final CountDownLatch countDownLatch = new CountDownLatch(numberOfInvalidThreadIds);
 
@@ -132,12 +129,12 @@ void testInvalidThreadIds() {
         new ThreadWithInvalidId(-i, new TestRunnable(countDownLatch)).start();
       }
 
-      Map<String, Double> actual = getCountByState(registry.scrape());
+      Map<String, Double> after = getCountByState(registry.scrape());
+      double unknownAfter = after.getOrDefault("UNKNOWN", 0.0);
 
-      assertThat(actual).hasSameSizeAs(expected);
-      for (String threadState : expected.keySet()) {
-        assertThat(actual.get(threadState)).isEqualTo(expected.get(threadState));
-      }
+      // The UNKNOWN count should increase by exactly the number of invalid thread ids.
+      // Other states may change due to background threads, so we only assert on UNKNOWN.
+      assertThat(unknownAfter - unknownBefore).isEqualTo((double) numberOfInvalidThreadIds);
     } finally {
       for (int i = 0; i < numberOfInvalidThreadIds; i++) {
         countDownLatch.countDown();