What will be the output accessing a list on different threads?

Question

I have an ArrayList of Strings and two threads are concurrently accessing the list. What will the output of following snippet and why?

public static void main(String[] args) {
    final ArrayList<String> list = new ArrayList<String>();

    for (int i = 0; i < 100; i++) {
        list.add("Number" + i);
    }

    new Thread() {

        public void run() {
            for (String s : list) {
                System.out.println(s);
            }
        }
    }.start();

    new Thread() {
        public void run() {
            list.remove("Number5");
        }
    }.start();

}

I tried using the same code making the Arraylist synchronized using Collections.synchronizedList(list). It is still throwing java.util.ConcurrentModificationException.

Do you mean to ask, "Is this function thread safe"? – Mr Lister Oct 16 '15 at 09:42 — Mr Lister, Oct 16 '15 at 09:42

score 3 · Accepted Answer · answered Oct 16 '15 at 09:46

The Javadoc of synchronizedList clearly states that:

It is imperative that the user manually synchronize on the returned list when iterating over it:
List list = Collections.synchronizedList(new ArrayList());
 ...
synchronized (list) {
    Iterator i = list.iterator(); // Must be in synchronized block
    while (i.hasNext())
        foo(i.next());
}
Failure to follow this advice may result in non-deterministic behavior.

Since in this code you are removing from a List while you are iterating over it (in a different thread but it is the same instance of the List), a ConcurrentModificationException will be thrown.

Using Collections.synchronizedList, the following code will run fine.

final List<String> list = Collections.synchronizedList(new ArrayList<String>());
for (int i = 0; i < 100; i++) {
    list.add("Number" + i);
}

new Thread() {
    public void run() {
        synchronized (list) {
            for (String s : list) {
                System.out.println(s);
            }
        }
    }
}.start();

new Thread() {
    public void run() {
        synchronized (list) {
            list.remove("Number5");
        }
    }
}.start();

score 2 · Answer 2 · edited May 23 '17 at 11:44

You can put a lock on the list object using syncrhonized keyword.

Synchronized Keyword
Its overall purpose is to only allow one thread at a time into a particular section of code thus allowing us to protect, for example, variables or data from being corrupted by simultaneous modifications from different threads.

So this should work for you:

public static void main(String[] args) {
    ...

    new Thread() {

        public void run() {
        synchronized(list){
            for (String s : list) {
                System.out.println(s);
            }
        }
        }
    }.start();

    new Thread() {
        public void run() {
        synchronized(list){
                    list.remove("Number5");
        }
        }
    }.start();

}

NB: It depends on what logic you want btw. Do you want remove from the list as you iterate over it or? you want the two tasks to happen sequentially?

me too: was looking for the purpose. If required, I guess we will have to interleave the tasks between the two threads. Moreover, adding and removing is similar to a producer-consumer problem, (Printing the whole list requires the lock on whole list object, depending on the intention of the developer.) — a3.14_Infinity, Oct 16 '15 at 09:55
yeah exactly it all depends on the intention of the developer. But the developer is not commenting so.. :-) — dsharew, Oct 16 '15 at 09:57

YoungHobbit · Answer 3 · 2015-10-16T09:49:35.247

You are iterating (in first thread) and updating (in second thread) the same list object in the two different threads, so there is always (possibility) that it will throw java.util.ConcurrentModificationException.

In the java Iterator are fail-fast in nature, so as soon as they realize that underline structure has been changed, they will fail with the ConcurrentModificationException exception.

If you want to use the same list object for you needs, you consider synchronizing it, using the synchronized(list) in both the threads run method.

    public void run() {
        synchronized(list) {
          for (String s : list) {
              System.out.println(s);
          }
        }
    }

    public void run() {
        synchronized(list) {
          list.remove("Number5");
        }
    }

score 0 · Answer 4 · edited Oct 16 '15 at 09:55

0

I think you should use Vector instead of ArrayList for being ThreadSafe plus using Iterator for browsing your List.

edited Oct 16 '15 at 09:55

Irshad

3,071
5
30
51

answered Oct 16 '15 at 09:44

Adrien Belfy

3
3

What will be the output accessing a list on different threads?

4 Answers4