是否包含java.util.List线程安全的方法？

Question

I have java.util.List declared as follows:

private static List<String> extensions = null;

It is populated by single thread always.

But multiple threads can call simultaneously method contains(E e) on extensions .

Is it threadsafe ?

Answer 1

List is populated by single thread at startup and cannot be modified afterwards. Is now contains threadsafe?

If you're talking about an ArrayList<T> , as the tags suggest, then yes. It doesn't make sense to talk about the thread-safety of List<T> , because interfaces have no implementation.

Looking at arraylist's implementation ( here ), you can see it only reads shared-state, but it doesn't write anything.

Careful though:

1. Your field is of type List<T> . Can you guarantee that the runtime type of the variable stored on that field will always be ArrayList<T> ?
2. The more important question is: does the documentation say the method is thread-safe? If it doesn't, a future release of Java might make it tread- unsafe , which won't be considered a breaking change.

---

If one of your threads was inserting data while the other were calling Contains , then that wouldn't be thread-safe. Consider add 's implementation:

public void add(int index, E element) {
     rangeCheckForAdd(index);

     ensureCapacity(size+1);  // Increments modCount!!
     System.arraycopy(elementData, index, elementData, index + 1,
                      size - index);
     elementData[index] = element;
     size++;
}

Say you have a list with 4 elements, and its internal array has capacity for 6. The internal array would look like this {a, b, c, d, null, null} and the private field size would be set to 4, to delimit the list's boundaries.

If I now insert x at position 2, here's what'll happen:

1. arraycopy will shift c and d to the right, like so {a, b, c, c, d, null}
2. the next line will insert x , {a, b, x, c, d, null}
3. The next line will increase size to 5, updating the list's boundaries.

Notice how, if you called Contains(d) on the list between steps 1 and 3, false would be returned. That's because size is still set to 4, and the list appears as if it contained {a,b,c,c} , and {d,null} would be ignored.

Answer 2

List is populated by single thread at startup and cannot be modified afterwards. Is now contains threadsafe?

An object used in that way is called "effectively immutable"---the program is allowed to change the object, but it doesn't. The book, Java Concurrency in Practice by Brian Goetz has a section that deals specifically with safe publication of effectively immutable objects . http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601

The short answer (assuming that I am remembering it correctly) is that if you populate the list inside a constructor, and if no other thread can access the list before the constructor returns, then the list is safely published. I am assuming, of course, that the items you put in the list are also effectively immutable.

"Safe publication" means that other threads will be guaranteed to see the list in its intended, final state. If the list were not safely published, then threads running on different processors could see different versions of the list (potentially including some version where the list was in an inconsistent state that could crash your program when you tried to access it.)

Answer 3

No, List is not Thread safe by default. If you want to make it thread safe . Use Collections.synchronizedList().