Java ArrayList.add() method thread safe for purely parallel adding? [duplicate]

Answer 1

ArrayList.add() is not thread-safe. Even if you're not reading the list from other threads, you shouldn't rely on this logical assumption. Here's the definition of ArrayList.add():

public boolean add(E e) {
    ensureCapacity(size + 1);
    elementData[size++] = e;
    return true;
}

As an example of a problem that could arise without synchronization, the size attribute may be inconsistent after adding all elements. If you later try to get the number of elements, the result may not be correct.

Answer 2

It is not thread-safe. In the absence of synchronization, threads can trample on each other's modification of the list, or might not even see each other's changes to it. Either way, it will be corrupted.

You should get the code working first with Collections.synchronizedList or a synchronized statement around the add call.

If you find that the synchronization on every operation has too much overhead, the next alternative is to give each thread its own private ArrayList, and then periodically, or at the end, dump the contents of the private ArrayLists into the main ArrayList.

Answer 3

No, it's not thread-safe. Wrap your list using Collections.synchronizedList(), or use explicit synchronization when accessing the list.

Answer 4

For that you can use CopyOnWriteArrayListsince ArrayList is not thread safe.

CopyOnWriteArrayList

EDIT: I'm just gonna quote Oracle to show you that this is what you need:

A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array. This is ordinarily too costly, but may be more efficient than alternatives when traversal operations vastly outnumber mutations, and is useful when you cannot or don't want to synchronize traversals, yet need to preclude interference among concurrent threads.

Answer 5

No it is not thread safe.You have two options:

1. Either use a different collection: CopyOnWriteArrayList
2. Use explicit synchronization while making modifications to the array list in a multithreaded environment.

Answer 6

No, the add method uses a number of class level properties which have no thread safe control. Calling add() concurrently in multiple threads would be highly likely to cause problems.