fix: prevent ConcurrentModificationException in copy() when setAttribute() is called concurrently (BUG-8620)

Agent-Logs-Url: https://github.com/optimizely/android-sdk/sessions/9734d248-0b4a-4815-a88f-e54529087a55

Co-authored-by: muzahidul-opti <129880873+muzahidul-opti@users.noreply.github.com>

Author: Copilot

CHANGELOG.md

@@ -16,6 +16,7 @@ See [Feature Rollout docs](https://support.optimizely.com/hc/en-us/articles/4555
 ### Fixes and Improvements
 
 - Update cmab error handling ([#522](https://github.com/optimizely/android-sdk/pull/522))
+- Fix `ConcurrentModificationException` in `decide()` when `setAttribute()` is called concurrently ([#507](https://github.com/optimizely/android-sdk/issues/507), BUG-8620)
 
 
 ## 5.1.1

android-sdk/src/main/java/com/optimizely/ab/android/sdk/OptimizelyUserContextAndroid.java

@@ -84,6 +84,31 @@ public OptimizelyUserContextAndroid(@NonNull Optimizely optimizely,
         super(optimizely, userId, attributes, forcedDecisionsMap, qualifiedSegments, shouldIdentifyUser);
     }
 
+    /**
+     * Returns a copy of this user context with all current attributes, forced decisions, and qualified segments.
+     *
+     * <p>This override holds the mutex of the synchronized attributes map (and qualified segments list,
+     * if present) while the copy is being made. This prevents a {@link java.util.ConcurrentModificationException}
+     * that would otherwise occur when another thread calls {@link #setAttribute} concurrently, because
+     * {@link java.util.Collections#synchronizedMap} only guards individual operations — not the bulk
+     * iteration that happens inside {@code new HashMap<>(attributes)} during the copy constructor.</p>
+     *
+     * @return A new {@link OptimizelyUserContext} with the same state as this instance.
+     */
+    @Override
+    public OptimizelyUserContext copy() {
+        Map<String, Object> attrs = getAttributes();
+        List<String> segs = getQualifiedSegments();
+        synchronized (attrs) {
+            if (segs == null) {
+                return super.copy();
+            }
+            synchronized (segs) {
+                return super.copy();
+            }
+        }
+    }
+
     // ==================================================================
     // [SYNCHRONOUS DECIDE METHODS]
     // - "decideSync" methods skip async decision like cmab for backward compatibility.

android-sdk/src/test/java/com/optimizely/ab/android/sdk/OptimizelyUserContextAndroidTest.java

@@ -35,9 +35,14 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doReturn;
@@ -410,4 +415,70 @@ public void testDecideAllBlocking_withoutOptions() throws Exception {
         assertEquals(mockDecisionsMap, result);
     }
 
+    // ===========================================
+    // Regression test for BUG-8620:
+    // ConcurrentModificationException in copy() when setAttribute() is called concurrently
+    // ===========================================
+
+    @Test
+    public void testCopy_noConcurrentModificationExceptionWithConcurrentSetAttribute()
+            throws InterruptedException {
+        Map<String, Object> attributes = new HashMap<>();
+        for (int i = 0; i < 50; i++) {
+            attributes.put("key" + i, "value" + i);
+        }
+
+        OptimizelyUserContextAndroid userContext = new OptimizelyUserContextAndroid(
+            mockOptimizely,
+            TEST_USER_ID,
+            attributes
+        );
+
+        int numThreads = 10;
+        int iterations = 200;
+        CountDownLatch startLatch = new CountDownLatch(1);
+        CountDownLatch doneLatch = new CountDownLatch(numThreads * 2);
+        AtomicReference<Throwable> error = new AtomicReference<>();
+
+        // Writer threads: call setAttribute() concurrently while copy() runs
+        for (int t = 0; t < numThreads; t++) {
+            final int threadNum = t;
+            new Thread(() -> {
+                try {
+                    startLatch.await();
+                    for (int i = 0; i < iterations; i++) {
+                        userContext.setAttribute("concurrentKey" + threadNum + "_" + i, "val");
+                    }
+                } catch (Throwable e) {
+                    error.compareAndSet(null, e);
+                } finally {
+                    doneLatch.countDown();
+                }
+            }).start();
+        }
+
+        // Reader threads: call copy() concurrently while setAttribute() runs
+        for (int t = 0; t < numThreads; t++) {
+            new Thread(() -> {
+                try {
+                    startLatch.await();
+                    for (int i = 0; i < iterations; i++) {
+                        userContext.copy();
+                    }
+                } catch (Throwable e) {
+                    error.compareAndSet(null, e);
+                } finally {
+                    doneLatch.countDown();
+                }
+            }).start();
+        }
+
+        startLatch.countDown();
+        boolean completed = doneLatch.await(15, TimeUnit.SECONDS);
+
+        assertTrue("Threads did not complete within timeout", completed);
+        assertNull("Unexpected exception during concurrent copy/setAttribute: " + error.get(),
+            error.get());
+    }
+
 }