perf(core): Harden lazy lock init and mark AutoClosableReentrantLock internal (JAVA-588)

Replace the unreachable candidate fallback after a failed CAS with an
explicit non-null check, so a broken invariant fails loudly instead of
handing two threads different locks. Mark the class @ApiStatus.Internal
and make the lazy-allocation test assert the lock field directly.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: runningcode

sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java

@@ -3,6 +3,7 @@
 import io.sentry.ISentryLifecycleToken;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import java.util.concurrent.locks.ReentrantLock;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
@@ -17,6 +18,7 @@
  * was pure GC and main-thread overhead. We keep a {@link ReentrantLock} rather than reverting to
  * {@code synchronized} to stay friendly to virtual threads (Loom), see #3715.
  */
+@ApiStatus.Internal
 public final class AutoClosableReentrantLock {
 
   private static final @NotNull AtomicReferenceFieldUpdater<
@@ -38,14 +40,13 @@ public final class AutoClosableReentrantLock {
     if (existing != null) {
       return existing;
     }
-    // The loser of the race discards its candidate and uses the winner's lock, so all callers
-    // contend on the same instance.
     final @NotNull ReentrantLock candidate = new ReentrantLock();
     if (LOCK_UPDATER.compareAndSet(this, null, candidate)) {
       return candidate;
     }
-    final @Nullable ReentrantLock winner = lock;
-    return winner != null ? winner : candidate;
+    // The CAS can only fail because another thread installed its lock first, and the field is
+    // never reset, so all callers end up contending on that same instance.
+    return Objects.requireNonNull(lock, "lock must have been set by the winning thread");
   }
 
   @TestOnly
@@ -54,6 +55,11 @@ boolean isLocked() {
     return current != null && current.isLocked();
   }
 
+  @TestOnly
+  boolean isLockAllocated() {
+    return lock != null;
+  }
+
   static final class AutoClosableReentrantLockLifecycleToken implements ISentryLifecycleToken {
 
     private final @NotNull ReentrantLock lock;

sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt

@@ -19,7 +19,9 @@ class AutoClosableReentrantLockTest {
   @Test
   fun `does not allocate the underlying lock until first acquire`() {
     val lock = AutoClosableReentrantLock()
-    assertFalse(lock.isLocked)
+    assertFalse(lock.isLockAllocated)
+    lock.acquire().use {}
+    assertTrue(lock.isLockAllocated)
   }
 
   @Test