Thread-Safe List in Java

A regular ArrayList breaks when several threads change it at the same time. Items silently go missing, or the program crashes. This guide shows the problem with a runnable example, then compares the ways to get a thread-safe list in Java and when to use each one.

What does "thread-safe" mean?

A thread is an independent path of execution. Modern programs often run many threads at once, for example to handle several web requests in parallel. Code is thread-safe if it still works correctly when multiple threads use it at the same time.

Picture two people editing the same paper shopping list at the same moment. Both read "3 items", both write item #4 in the same spot, and one item is lost. That's a race condition.

Why isn't ArrayList thread-safe?

Adding to an ArrayList is several steps: check the size, maybe grow the array, store the item, increase the size. If two threads interleave those steps, they can overwrite each other's work. Try it:

import java.util.ArrayList;
import java.util.List;

public class RaceDemo {
    public static void main(String[] args) throws InterruptedException {
        List<Integer> list = new ArrayList<>();

        Runnable addMany = () -> {
            for (int i = 0; i < 10_000; i++) {
                list.add(i);
            }
        };

        Thread t1 = new Thread(addMany);
        Thread t2 = new Thread(addMany);
        t1.start(); t2.start();      // run both at the same time
        t1.join();  t2.join();       // wait for both to finish

        System.out.println("Expected 20000, got " + list.size());
    }
}

Expected 20000, got 12129

That was one real run on a laptop. Five more runs gave 11908, 12256, 12379, 12523, and one crash.

The exact number changes every run, and sometimes the program throws an ArrayIndexOutOfBoundsException instead. Bugs like this are dangerous precisely because they're random: the code can pass every test on your laptop and fail in production.

What are the thread-safe list options?

List<String> list = Collections.synchronizedList(new ArrayList<>());

List<String> listeners = new CopyOnWriteArrayList<>();

List<String> countries = List.of("LK", "IN", "US");
List<String> snapshot = List.copyOf(mutableList);

List<String> old = new Vector<>();   // avoid in new code

Option 1: Collections.synchronizedList

Wrap any list, and each method call becomes safe. Fixing our demo is a one-line change:

List<Integer> list = Collections.synchronizedList(new ArrayList<>());
// ...same two threads as before...

Expected 20000, got 20000

synchronized (list) {             // hold the lock for the whole loop
    for (Integer n : list) {
        System.out.println(n);
    }
}

Option 2: CopyOnWriteArrayList

From java.util.concurrent. Every change makes a fresh copy of the internal array, so readers always see a complete, unchanging snapshot. Loops need no locking and never throw ConcurrentModificationException:

List<String> names = new CopyOnWriteArrayList<>(List.of("Asha", "Ben"));

for (String n : names) {
    names.add(n + "!");       // safe: the loop keeps reading its original snapshot
}
System.out.println(names);

[Asha, Ben, Asha!, Ben!]

Notice the loop didn't run forever, even though we kept adding. It iterated over the snapshot from when the loop started. Ideal for things like a list of event listeners: read on every event, changed only occasionally.

Option 3: don't share changeable lists at all

The safest shared list is one that never changes. List.of(...) and List.copyOf(...) create unmodifiable lists that any number of threads can read with zero locking. To "change" one, build a new list and publish that instead.

Thread-safe lists compared

Quick recap

What's next?

You've finished the core Java series. Put it to work with real-world tools: explore Java web frameworks or Java persistence frameworks, or go back to the Java overview.