ref(profiling): Improve thread safety in PerfettoContinuousProfiler

- Add lock to isRunning(), getProfilerId(), getChunkId() so all public
  getters are synchronized with writes in startInternal/stopInternal
- Add lock to reevaluateSampling() and remove volatile from shouldSample;
  all accesses are now under the same lock
- Add Caller must hold lock javadoc to resolveScopes()
- Add class-level javadoc documenting the threading/locking policy
- Replace ArrayDeque with ConcurrentLinkedDeque in PerfettoProfiler for
  frame measurement collections; these are written by the FrameMetrics
  HandlerThread and read by the executor thread in endAndCollect()

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

Author: 43jay

sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java

@@ -45,6 +45,12 @@
  * <p>Unlike the legacy profiler, this class is not used for app-start profiling. It is created
  * during {@code Sentry.init()}, so scopes are always available when {@link #startProfiler} is
  * called.
+ *
+ * <p>Thread safety: all mutable state is guarded by a single {@link
+ * io.sentry.util.AutoClosableReentrantLock}. Public entry points ({@link #startProfiler}, {@link
+ * #stopProfiler}, {@link #close}, {@link #onRateLimitChanged}, {@link #reevaluateSampling}, and
+ * the getters) acquire the lock themselves. Private methods {@code startInternal} and {@code
+ * stopInternal} require the caller to hold the lock.
  */
 @ApiStatus.Internal
 @RequiresApi(api = Build.VERSION_CODES.VANILLA_ICE_CREAM)
@@ -70,7 +76,7 @@ public class PerfettoContinuousProfiler
   private final @NotNull AtomicBoolean isClosed = new AtomicBoolean(false);
   private @NotNull SentryDate startProfileChunkTimestamp =
       new io.sentry.SentryNanotimeDate();
-  private volatile boolean shouldSample = true;
+  private boolean shouldSample = true;
   private boolean shouldStop = false;
   private boolean isSampled = false;
   private int activeTraceCount = 0;
@@ -145,10 +151,9 @@ public void stopProfiler(final @NotNull ProfileLifecycle profileLifecycle) {
   }
 
   /**
-   * Stop the profiler as soon as we are rate limited, to avoid the performance overhead
+   * Stop the profiler as soon as we are rate limited, to avoid the performance overhead.
    *
-   * @param rateLimiter this {@link RateLimiter} instance which you can use to check if the rate
-   *     limit is active for a specific category
+   * @param rateLimiter the {@link RateLimiter} instance to check categories against
    */
   @Override
   public void onRateLimitChanged(@NotNull RateLimiter rateLimiter) {
@@ -177,23 +182,31 @@ public void close(final boolean isTerminating) {
 
   @Override
   public @NotNull SentryId getProfilerId() {
-    return profilerId;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return profilerId;
+    }
   }
 
   @Override
   public @NotNull SentryId getChunkId() {
-    return chunkId;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return chunkId;
+    }
   }
 
   @Override
   public boolean isRunning() {
-    return isRunning;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return isRunning;
+    }
   }
 
   /**
    * Resolves scopes on first call. Since PerfettoContinuousProfiler is created during
    * Sentry.init() and never used for app-start profiling, scopes is guaranteed to be available by
    * the time startProfiler is called.
+   *
+   * <p>Caller must hold {@link #lock}.
    */
   private @NotNull IScopes resolveScopes() {
     if (scopes != null && scopes != NoOpScopes.getInstance()) {
@@ -350,7 +363,9 @@ private void ensureProfiler() {
   }
 
   public void reevaluateSampling() {
-    shouldSample = true;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      shouldSample = true;
+    }
   }
 
   private void sendChunk(

sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java

@@ -14,8 +14,8 @@
 import io.sentry.profilemeasurements.ProfileMeasurement;
 import io.sentry.profilemeasurements.ProfileMeasurementValue;
 import java.io.File;
-import java.util.ArrayDeque;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -46,12 +46,14 @@ public class PerfettoProfiler {
   private @Nullable ProfilingResult profilingResult = null;
   private @Nullable CountDownLatch resultLatch = null;
 
-  private final @NotNull ArrayDeque<ProfileMeasurementValue> slowFrameRenderMeasurements =
-      new ArrayDeque<>();
-  private final @NotNull ArrayDeque<ProfileMeasurementValue> frozenFrameRenderMeasurements =
-      new ArrayDeque<>();
-  private final @NotNull ArrayDeque<ProfileMeasurementValue> screenFrameRateMeasurements =
-      new ArrayDeque<>();
+  // ConcurrentLinkedDeque because onFrameMetricCollected (HandlerThread) and endAndCollect
+  // (executor thread) can access these concurrently.
+  private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+      slowFrameRenderMeasurements = new ConcurrentLinkedDeque<>();
+  private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+      frozenFrameRenderMeasurements = new ConcurrentLinkedDeque<>();
+  private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+      screenFrameRateMeasurements = new ConcurrentLinkedDeque<>();
   private final @NotNull Map<String, ProfileMeasurement> measurementsMap = new HashMap<>();
 
   /**