Re-use thread

Author: markushi

sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfilingIntegration.java

@@ -48,6 +48,8 @@ public class AnrProfilingIntegration
   private volatile @Nullable SentryAndroidOptions options;
   private volatile @Nullable Thread thread = null;
   private volatile boolean inForeground = false;
+  private volatile @Nullable Handler mainHandler;
+  private volatile @Nullable Thread mainThread;
 
   @Override
   public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions options) {
@@ -63,17 +65,35 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
         return;
       }
 
+      final Looper mainLooper = Looper.getMainLooper();
+      this.mainThread = mainLooper.getThread();
+      this.mainHandler = new Handler(mainLooper);
+
       addIntegrationToSdkVersion("AnrProfiling");
       AppState.getInstance().addAppStateListener(this);
     }
   }
 
   @Override
   public void close() throws IOException {
-    onBackground();
     enabled.set(false);
     AppState.getInstance().removeAppStateListener(this);
 
+    // Remove any pending updater callbacks from the main handler
+    final @Nullable Handler handler = mainHandler;
+    if (handler != null) {
+      handler.removeCallbacks(updater);
+    }
+
+    // Wake and interrupt the thread so it exits
+    final @Nullable Thread t = thread;
+    if (t != null) {
+      synchronized (this) {
+        notifyAll();
+      }
+      t.interrupt();
+    }
+
     final @Nullable SentryAndroidOptions opts = options;
     if (opts != null) {
       try {
@@ -95,7 +115,7 @@ public void run() {
                     }
                   }
                 });
-      } catch (Throwable t) {
+      } catch (Throwable e) {
         logger.log(SentryLevel.WARNING, "Failed to submit AnrProfileManager close");
       }
     }
@@ -113,15 +133,19 @@ public void onForeground() {
       inForeground = true;
       updater.run();
 
-      final @Nullable Thread oldThread = thread;
-      if (oldThread != null) {
-        oldThread.interrupt();
+      final @Nullable Thread existingThread = thread;
+      if (existingThread != null && existingThread.isAlive()) {
+        // Wake the existing thread
+        synchronized (this) {
+          notifyAll();
+        }
+      }
+      if (existingThread == null || !existingThread.isAlive()) {
+        final @NotNull Thread profilingThread = new Thread(this, "AnrProfilingIntegration");
+        profilingThread.setDaemon(true);
+        profilingThread.start();
+        thread = profilingThread;
       }
-
-      final @NotNull Thread profilingThread = new Thread(this, "AnrProfilingIntegration");
-      profilingThread.setDaemon(true);
-      profilingThread.start();
-      thread = profilingThread;
     }
   }
 
@@ -131,32 +155,37 @@ public void onBackground() {
       return;
     }
     try (final @NotNull ISentryLifecycleToken ignored = lifecycleLock.acquire()) {
-      if (!inForeground) {
-        return;
-      }
-
       inForeground = false;
-      final @Nullable Thread oldThread = thread;
-      if (oldThread != null) {
-        oldThread.interrupt();
-      }
     }
   }
 
   @Override
   public void run() {
-    // get main thread Handler so we can post messages
-    final Looper mainLooper = Looper.getMainLooper();
-    final Thread mainThread = mainLooper.getThread();
-    final Handler mainHandler = new Handler(mainLooper);
+    final @Nullable Handler handler = mainHandler;
+    final @Nullable Thread mt = mainThread;
+    if (handler == null || mt == null) {
+      return;
+    }
 
     try {
       while (enabled.get() && !Thread.currentThread().isInterrupted()) {
         try {
-          checkMainThread(mainThread);
+          if (!inForeground) {
+            // Wait until we're back in the foreground or disabled
+            synchronized (this) {
+              while (!inForeground && enabled.get()) {
+                wait();
+              }
+            }
+            // Reset the updater timestamp after waking to avoid false suspicion
+            updater.run();
+            continue;
+          }
+
+          checkMainThread(mt);
 
-          mainHandler.removeCallbacks(updater);
-          mainHandler.post(updater);
+          handler.removeCallbacks(updater);
+          handler.post(updater);
 
           // noinspection BusyWait
           Thread.sleep(POLLING_INTERVAL_MS);

sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt

@@ -15,6 +15,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
+import kotlin.test.assertSame
 import kotlin.test.assertTrue
 import org.junit.Rule
 import org.junit.rules.TemporaryFolder
@@ -63,7 +64,7 @@ class AnrProfilingIntegrationTest {
   }
 
   @Test
-  fun `onBackground stops monitoring thread`() {
+  fun `onBackground pauses monitoring thread`() {
     val integration = AnrProfilingIntegration()
     integration.register(mockScopes, options)
     integration.onForeground()
@@ -73,9 +74,14 @@ class AnrProfilingIntegrationTest {
     assertNotNull(thread)
 
     integration.onBackground()
-    thread.join(2000) // Wait for thread to stop
+    Thread.sleep(200) // Allow thread to enter wait state
 
-    assertTrue(!thread.isAlive)
+    // Thread should still be alive but waiting
+    assertTrue(thread.isAlive)
+
+    integration.close()
+    thread.join(2000)
+    assertFalse(thread.isAlive)
   }
 
   @Test
@@ -132,8 +138,7 @@ class AnrProfilingIntegrationTest {
   }
 
   @Test
-  fun `foreground after background restarts thread`() {
-    // Arrange
+  fun `foreground after background reuses thread`() {
     val integration = AnrProfilingIntegration()
     integration.register(mockScopes, options)
 
@@ -149,7 +154,8 @@ class AnrProfilingIntegrationTest {
 
     assertNotNull(thread1)
     assertNotNull(thread2)
-    assertTrue(thread1 != thread2, "Should create a new thread after background")
+    assertSame(thread1, thread2, "Should reuse the same thread after background")
+    assertTrue(thread1.isAlive)
 
     integration.close()
   }