Polish

See gh-5222

Author: shakuzen

micrometer-core/src/main/java/io/micrometer/core/instrument/binder/jvm/JvmThreadDeadlockMetrics.java

@@ -31,13 +31,12 @@
 import static java.util.Collections.emptyList;
 
 /**
- * {@link MeterBinder} for JVM deadlocked threads. These metrics are somewhat expensive to
- * collect, so they should not be enabled unless necessary. To enable these metrics, add
- * the following to your application's code ({@code registry} is the meter registry being
- * used by your application):
- * <pre>{@code new JvmDeadlockedThreadMetrics().bindTo(registry);}</pre>
+ * {@link MeterBinder} for JVM deadlocked threads. These metrics may be expensive to
+ * collect. Consider that when deciding whether to enable these metrics. To enable these
+ * metrics, bind an instance of this to a {@link MeterRegistry}.
  *
  * @author Ruth Kurniawati
+ * @since 1.14.0
  */
 @NonNullApi
 @NonNullFields
@@ -59,7 +58,7 @@ public JvmThreadDeadlockMetrics(Iterable<Tag> tags) {
     public void bindTo(MeterRegistry registry) {
         ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
 
-        if (threadBean.isObjectMonitorUsageSupported()) {
+        if (threadBean.isSynchronizerUsageSupported()) {
             Gauge.builder("jvm.threads.deadlocked", threadBean, JvmThreadDeadlockMetrics::getDeadlockedThreadCount)
                 .tags(tags)
                 .description("The current number of threads that are deadlocked")

micrometer-core/src/test/java/io/micrometer/core/instrument/binder/jvm/JvmThreadDeadlockMetricsTest.java

@@ -40,36 +40,10 @@
  */
 class JvmThreadDeadlockMetricsTest {
 
-    private static class DeadlockedThread {
-
-        private final Thread thread;
-
-        DeadlockedThread(CountDownLatch lock1IsLocked, Lock lock1, CountDownLatch lock2IsLocked, Lock lock2) {
-            this.thread = new Thread(() -> {
-                try {
-                    lock1.lock();
-                    lock1IsLocked.countDown();
-                    lock2IsLocked.await();
-                    lock2.lockInterruptibly();
-                }
-                catch (InterruptedException ignored) {
-                }
-            });
-        }
-
-        void start() {
-            thread.start();
-        }
-
-        void interrupt() {
-            thread.interrupt();
-        }
-
-    }
+    MeterRegistry registry = new SimpleMeterRegistry();
 
     @Test
     void deadlockedThreadMetrics() {
-        MeterRegistry registry = new SimpleMeterRegistry();
         new JvmThreadDeadlockMetrics().bindTo(registry);
         final CountDownLatch lock1IsLocked = new CountDownLatch(1);
         final CountDownLatch lock2IsLocked = new CountDownLatch(1);
@@ -90,16 +64,14 @@ void deadlockedThreadMetrics() {
     }
 
     @Test
-    void whenJvmDoesntSupportObjectMonitorUsageJvmThreadsDeadlockedMetricShouldNotBeRegistered() {
-        MeterRegistry registry = new SimpleMeterRegistry();
+    void whenJvmDoesntSupportSynchronizerUsage_JvmThreadsDeadlockedMetricShouldNotBeRegistered() {
         try (MockedStatic<ManagementFactory> mockedStatic = Mockito.mockStatic(ManagementFactory.class)) {
             ThreadMXBean threadBean = mock(ThreadMXBean.class);
-            when(threadBean.isObjectMonitorUsageSupported()).thenReturn(false);
+            when(threadBean.isSynchronizerUsageSupported()).thenReturn(false);
             mockedStatic.when(ManagementFactory::getThreadMXBean).thenReturn(threadBean);
             new JvmThreadDeadlockMetrics().bindTo(registry);
 
-            // ObjectMonitorUsage is not supported, so this metric should not be
-            // registered
+            // synchronizer usage is not monitored, so this should not be registered
             assertThat(registry.find("jvm.threads.deadlocked").gauge()).isNull();
             // but this one is still supported
             assertThat(registry.find("jvm.threads.deadlocked.monitor").gauge()).isNotNull();
@@ -120,4 +92,31 @@ void getDeadlockedThreadCountWhenFindMonitorDeadlockedThreadsIsNullShouldWork()
         assertThat(JvmThreadDeadlockMetrics.getDeadlockedMonitorThreadCount(threadBean)).isEqualTo(0);
     }
 
+    private static class DeadlockedThread {
+
+        private final Thread thread;
+
+        DeadlockedThread(CountDownLatch lock1IsLocked, Lock lock1, CountDownLatch lock2IsLocked, Lock lock2) {
+            this.thread = new Thread(() -> {
+                try {
+                    lock1.lock();
+                    lock1IsLocked.countDown();
+                    lock2IsLocked.await();
+                    lock2.lockInterruptibly();
+                }
+                catch (InterruptedException ignored) {
+                }
+            });
+        }
+
+        void start() {
+            thread.start();
+        }
+
+        void interrupt() {
+            thread.interrupt();
+        }
+
+    }
+
 }