Re: Vector (was Re: Change character in string)
Peter Duniho wrote:
On Fri, 13 Mar 2009 20:45:49 -0700, Lew <noone@lewscanon.com> wrote:
Bent C Dalager wrote:
On 2009-03-14, Lew <noone@lewscanon.com> wrote:
Now I have quite the mental exercise ahead of me to figure out why
'Vector#equals()' deadlocks and 'SynchronizedList#equals()' doesn't.
The listIterator that ArrayList uses to access the other lists's
objects isn't synchronized. It is provided by the backing list and
doesn't get wrapped by SynchronizedList.
OK, but neither is the 'Vector#listIterator()' method, which is
inherited from 'AbstractList' and therefore not synchronized.
The get() is synchronized.
But when I look at the source for 'Vector' I don't see 'get()' invoked in the
'equals()' implementation:
public synchronized boolean equals(Object o) {
return super.equals(o);
}
which calls:
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof List))
return false;
ListIterator<E> e1 = listIterator();
ListIterator e2 = ((List) o).listIterator();
while(e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
The 'synchronizedList()' wrapped version of the 'ArrayList' goes through
synchronized(mutex) {return list.equals(o);}
so, although the iterator itself isn't synchronized, it is called from
a synchronized code block, as is 'Vector''s.
I'm still not spotting the difference, exactly.
If I understand Bent's comments correctly:
Vector: for any given instance, the equals() method itself is
synchronized, and the getter to retrieve each element of the _other_
What getter? This is what I'm missing.
list being compared to is synchronized. There are two Vector
instances. Calling equals() on each, one thread per, locks both. This
lock won't be released until the equals() method has completed. The
equals() method won't complete until it has successfully retrieved each
element from the _other_ list. But it can't, because the other list got
locked when the other thread called equals().
I thought of that, but I didn't see how that differed from two synchronized
lists calling 'equals()', one in each thread. I don't see any use of a getter.
--
Lew