Java线程安全代码

Question

I saw the code below on the web, and it says "the code is not thread safe". I could not understand why? Since, each thread below runs the getList will not let any other one to reach to the getList() .

public class MyClass {
    private List<String> list;

    public static void main (String[] args) throws InterruptedException {
        MyClass obj = new MyClass();

        Thread thread1 = new Thread(() -> {
            System.out.println("thread1 : " + System.identityHashCode(obj.getList()));
        });
        Thread thread2 = new Thread(() -> {
            System.out.println("thread2 : " + System.identityHashCode(obj.getList()));
        });

        thread1.start();
        thread2.start();
    }

    private List<String> getList () {
        if (list == null) {
            list = new ArrayList<>();
        }
        return list;
    }
}

Answer 1

This line makes the program not thread-safe

if (list == null) {

Both threads might see the list is null at the same time and try to assign them new array.

Answer 2

You have mutable state (the member variable list ) that is shared between the two threads.

The two threads can access:

if (list == null) {

and modify:

        list = new ArrayList<>();

the shared mutable state through the getlist method, which is not synchronized in any way.

Therefore, this code is not thread safe. Accessing and modifying shared mutable state without synchronization is a bad idea in general.

Answer 3

This code is unsafe for two reasons, both centering on these statements:

if (list == null) {
    list = new ArrayList<>();
}
return list;

First problem is that there is a race condition. On a system with multiple cores, there is a tiny probability that two threads will read list at exactly the same time, both threads will see null , and two ArrayList objects will be created and returned. And on a single core system, there is an even smaller probability that one thread will be preempted by the other immediately after reading list and you will get the same result.

But there is a more insidious problem that related to the Java Memory Model. The fact that there is no synchronization means that there is no happens-before relationship between one thread writing list and another thread (subsequently) reading it. That means that the Java interpreter / JIT compiler are not obliged to insert memory barrier sequences to ensure that the value written by the earlier thread is visible to the later thread. So even in the case where the two threads run at different times ... the later thread may not see the non-null value written by the earlier thread due to various memory caching effects.

The solution to both problems is to synchronize properly; eg like this:

synchronized (this) {
    if (list == null) {
        list = new ArrayList<>();
    }
    return list;
}

or by declaring the method to be synchronized .