如何同步单进程与并行组？解决ArrayList并发修改异常及下载锁问题

Hey there! Let's tackle your ConcurrentModificationException problem while keeping those chart downloads running in parallel—no more unwanted serial execution.

First, let's understand why your current setup is forcing everything to run one after another: you're using the same global lock object for both the download and write operations. Every cell's download thread has to wait for the lock to be released before it can even start downloading, which kills parallelism. The key here is to separate the download work (which can be parallel) from the ArrayList modification (which needs to be thread-safe).

Here are three solid approaches to fix this:

1. Separate Parallel Downloads from Thread-Safe Writes #

Let each thread handle its own download first (no locking here—this is where parallelism happens), then only lock when you need to write the result to the ArrayList. Since writing is usually a fast operation, the lock contention will be minimal, and your downloads stay parallel.

Example code:

// Keep your lock in the Fragment
public static final Object lock = new Object();

// In each Cell's download logic
new Thread(() -> {
    // Step 1: Download the chart in parallel (no lock needed!)
    ChartData downloadedChart = downloadChartData(); // Your download method here
    
    // Step 2: Lock ONLY when modifying the ArrayList
    synchronized (lock) {
        yourChartDataList.add(downloadedChart);
        // Update RecyclerView safely (post to main thread)
        yourRecyclerView.post(() -> yourAdapter.notifyDataSetChanged());
    }
}).start();

This way, all downloads run at the same time, and only the quick write operations sync up briefly.

2. Use a Thread-Safe Collection Instead of ArrayList #

If you want to avoid manual locking entirely, swap your ArrayList for CopyOnWriteArrayList. This collection is designed for thread safety: every modification (like add() or remove()) creates a new copy of the underlying array, so reads are completely lock-free, and writes are handled safely in the background.

Just note: this works best if you don't have super frequent writes (since copying the array has a small overhead). Here's how to use it:

// Replace your ArrayList with CopyOnWriteArrayList
private CopyOnWriteArrayList<ChartData> yourChartDataList = new CopyOnWriteArrayList<>();

// In each Cell's download logic
new Thread(() -> {
    ChartData downloadedChart = downloadChartData();
    // No lock needed—CopyOnWriteArrayList handles thread safety internally
    yourChartDataList.add(downloadedChart);
    yourRecyclerView.post(() -> yourAdapter.notifyDataSetChanged());
}).start();

3. Use a Dedicated Thread for ArrayList Modifications #

Create a single background thread that handles all writes to the ArrayList. Your download threads run in parallel, and when they finish, they send the result to this dedicated thread to perform the write. This guarantees no concurrent modifications, and downloads stay parallel.

Example with HandlerThread:

private HandlerThread writeThread;
private Handler writeHandler;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Initialize the dedicated write thread
    writeThread = new HandlerThread("ChartWriteThread");
    writeThread.start();
    writeHandler = new Handler(writeThread.getLooper());
}

// In each Cell's download logic
new Thread(() -> {
    ChartData downloadedChart = downloadChartData();
    // Post the write task to the dedicated thread
    writeHandler.post(() -> {
        yourChartDataList.add(downloadedChart);
        yourRecyclerView.post(() -> yourAdapter.notifyDataSetChanged());
    });
}).start();

@Override
public void onDestroy() {
    super.onDestroy();
    // Clean up the thread to avoid leaks
    writeThread.quitSafely();
}

Which One Should You Choose? #

• Go with CopyOnWriteArrayList if you want the simplest code and have infrequent writes.
• Use the separate download/write lock approach if you need maximum performance and want fine-grained control.
• Pick the dedicated write thread if you want a rock-solid, predictable setup (great for more frequent writes).

All of these will fix your ConcurrentModificationException while keeping your downloads running in parallel—no more serial waiting!

内容的提问来源于stack exchange，提问作者Vadim