为什么SynchronizedList的listIterator需要用户进行外部同步？

Question

Please refer to the following java source code :

static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {

final List<E> list;

public boolean equals(Object o) {
    synchronized (mutex) {return list.equals(o);}
}
public int hashCode() {
    synchronized (mutex) {return list.hashCode();}
}

public ListIterator<E> listIterator() {
    return list.listIterator(); //Must be manually synched by user
}

My question is why is the listIterator() not guarded by the mutex as with hashcode() and equals() method ? Why did they design it so that it requires external synchronization by the user ?

Answer 1

If you suggest:

public ListIterator<E> listIterator() {
    synchronized(mutex) { return list.listIterator(); }
}

That won't help much.

You'd synchronize the creation of the iterator itself, which might help against a few issues. But you won't synchronize the use of the iterator. Changes can still be made to the list while you hold the iterator and - implementation depending - may even cause it to fail, because the list may be in an invalid internal state temporarily.

Answer 2

The main usage of ListIterator is not in obtaining it , but actually iterating it over for visiting individual elements in the list. This is a stateful operation and is entirely done by the client and not by the class SynchronizedList . On the other hand , the methods equals() and hashCode() are entirely computed within the SynchronizedList and do not require client to do much expect to take the returned values. Synchronizing the method to obtain the iterator is not much helpful as user1252434 pointed out.

ListIterator is a classic example of using client-side locking as a strategy to ensure synchronization when the original class cannot provide for this.

Answer 3

There could be two possible reasons.

We have three different Implementation of List interface . One is Vector and other two are ArrayList and LinkedList .

One reason is If we are dealing with Vectors then defiantly no synchronization is required on Vector because it is already thread-safe but if we are using ArrayList and LinkedList then we need to synchronize these Lists

Other reason is we can use SynchronizedList class in Single-Threaded Application if they would have made listIterator() as Synchronized then this is performance hit by unnecessary thread-safety even in single-threaded environment.