perf(core): Lazily allocate AutoClosableReentrantLock (JAVA-588) (#5643)

* perf(core): Lazily allocate AutoClosableReentrantLock (JAVA-588)

AutoClosableReentrantLock extended ReentrantLock, so every SDK object
holding one allocated a ReentrantLock (and its AbstractQueuedSynchronizer)
eagerly in its field initializer. A customer Perfetto trace showed ~81 such
allocations on the main thread during SentryAndroid.init, many for locks
that are never acquired during init.

Hold the ReentrantLock internally and create it lazily on first acquire(),
using an AtomicReferenceFieldUpdater CAS so creation stays atomic and
Loom-friendly (no synchronized, preserving #3715). Every call site uses
acquire() only, so dropping the ReentrantLock superclass touches no caller.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* 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>

* perf(core): Return the lock itself as the lifecycle token (JAVA-588)

Every acquire() allocated a fresh lifecycle token, which is per-use
garbage on every lock acquisition forever, not just at init. The token
was stateless apart from its lock reference, so AutoClosableReentrantLock
now implements ISentryLifecycleToken itself and acquire() returns this,
making the steady-state acquire/close path allocation-free. Semantics
are unchanged: try-with-resources closes once per acquire, so reentrant
acquires stay balanced, and unlocking without holding the lock still
throws IllegalMonitorStateException.

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

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: runningcode

CHANGELOG.md

@@ -21,6 +21,7 @@
 - Avoid constructing an exception per view when resolving view ids during view-hierarchy and gesture capture ([#5631](https://github.com/getsentry/sentry-java/pull/5631))
 - Start the frame metrics thread lazily on first collection instead of during SDK init ([#5641](https://github.com/getsentry/sentry-java/pull/5641))
 - Reduce `SentryId` and `SpanId` allocation overhead by replacing their per-instance `LazyEvaluator` (and its lock) with a lightweight lazily-generated `String`. ([#5645](https://github.com/getsentry/sentry-java/pull/5645))
+- Lazily allocate the `ReentrantLock` backing `AutoClosableReentrantLock` to avoid eager lock allocations for SDK objects that never contend during `SentryAndroid.init` ([#5643](https://github.com/getsentry/sentry-java/pull/5643))
 
 ## 8.46.0
 

sentry/api/sentry.api

@@ -7589,9 +7589,10 @@ public abstract class io/sentry/transport/TransportResult {
 	public static fun success ()Lio/sentry/transport/TransportResult;
 }
 
-public final class io/sentry/util/AutoClosableReentrantLock : java/util/concurrent/locks/ReentrantLock {
+public final class io/sentry/util/AutoClosableReentrantLock : io/sentry/ISentryLifecycleToken {
 	public fun <init> ()V
 	public fun acquire ()Lio/sentry/ISentryLifecycleToken;
+	public fun close ()V
 }
 
 public final class io/sentry/util/CheckInUtils {

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

@@ -1,29 +1,70 @@
 package io.sentry.util;
 
 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;
 
-public final class AutoClosableReentrantLock extends ReentrantLock {
+/**
+ * Hands out an {@link ISentryLifecycleToken} from {@link #acquire()} for use with
+ * try-with-resources (replacing {@code synchronized} blocks).
+ *
+ * <p>The underlying {@link ReentrantLock} is created lazily on the first {@link #acquire()}. Many
+ * SDK objects hold a lock but never contend on it (especially during {@code SentryAndroid.init}),
+ * so the eager allocation of a {@link ReentrantLock} (and its {@code AbstractQueuedSynchronizer})
+ * 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.
+ *
+ * <p>{@link #acquire()} returns this instance as the token, so the steady-state acquire/close path
+ * allocates nothing. Reentrant acquires stay balanced because try-with-resources calls {@link
+ * #close()} exactly once per acquire.
+ */
+@ApiStatus.Internal
+public final class AutoClosableReentrantLock implements ISentryLifecycleToken {
 
-  private static final long serialVersionUID = -3283069816958445549L;
+  private static final @NotNull AtomicReferenceFieldUpdater<
+          AutoClosableReentrantLock, ReentrantLock>
+      LOCK_UPDATER =
+          AtomicReferenceFieldUpdater.newUpdater(
+              AutoClosableReentrantLock.class, ReentrantLock.class, "lock");
 
-  public ISentryLifecycleToken acquire() {
-    lock();
-    return new AutoClosableReentrantLockLifecycleToken(this);
-  }
+  private volatile @Nullable ReentrantLock lock;
 
-  static final class AutoClosableReentrantLockLifecycleToken implements ISentryLifecycleToken {
+  public @NotNull ISentryLifecycleToken acquire() {
+    getOrCreateLock().lock();
+    return this;
+  }
 
-    private final @NotNull ReentrantLock lock;
+  @Override
+  public void close() {
+    Objects.requireNonNull(lock, "close() called before acquire()").unlock();
+  }
 
-    AutoClosableReentrantLockLifecycleToken(final @NotNull ReentrantLock lock) {
-      this.lock = lock;
+  private @NotNull ReentrantLock getOrCreateLock() {
+    final @Nullable ReentrantLock existing = lock;
+    if (existing != null) {
+      return existing;
     }
-
-    @Override
-    public void close() {
-      lock.unlock();
+    final @NotNull ReentrantLock candidate = new ReentrantLock();
+    if (LOCK_UPDATER.compareAndSet(this, null, candidate)) {
+      return 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
+  boolean isLocked() {
+    final @Nullable ReentrantLock current = lock;
+    return current != null && current.isLocked();
+  }
+
+  @TestOnly
+  boolean isLockAllocated() {
+    return lock != null;
   }
 }

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

@@ -1,7 +1,12 @@
 package io.sentry.util
 
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertSame
 import kotlin.test.assertTrue
 
 class AutoClosableReentrantLockTest {
@@ -11,4 +16,57 @@ class AutoClosableReentrantLockTest {
     lock.acquire().use { assertTrue(lock.isLocked) }
     assertFalse(lock.isLocked)
   }
+
+  @Test
+  fun `acquire returns the lock itself as the token, allocating nothing`() {
+    val lock = AutoClosableReentrantLock()
+    lock.acquire().use { token -> assertSame(lock, token) }
+  }
+
+  @Test
+  fun `does not allocate the underlying lock until first acquire`() {
+    val lock = AutoClosableReentrantLock()
+    assertFalse(lock.isLockAllocated)
+    lock.acquire().use {}
+    assertTrue(lock.isLockAllocated)
+  }
+
+  @Test
+  fun `supports reentrant acquire from the same thread`() {
+    val lock = AutoClosableReentrantLock()
+    lock.acquire().use {
+      lock.acquire().use { assertTrue(lock.isLocked) }
+      assertTrue(lock.isLocked)
+    }
+    assertFalse(lock.isLocked)
+  }
+
+  @Test
+  fun `mutually excludes concurrent threads`() {
+    val lock = AutoClosableReentrantLock()
+    val inCriticalSection = AtomicInteger(0)
+    val maxObserved = AtomicInteger(0)
+    val start = CountDownLatch(1)
+    val threadCount = 8
+    val iterations = 1000
+    val threads =
+      (0 until threadCount).map {
+        Thread {
+          start.await()
+          repeat(iterations) {
+            lock.acquire().use {
+              val current = inCriticalSection.incrementAndGet()
+              maxObserved.accumulateAndGet(current, ::maxOf)
+              inCriticalSection.decrementAndGet()
+            }
+          }
+        }
+      }
+    threads.forEach(Thread::start)
+    start.countDown()
+    threads.forEach { it.join(TimeUnit.SECONDS.toMillis(10)) }
+
+    assertEquals(1, maxObserved.get())
+    assertFalse(lock.isLocked)
+  }
 }