Effective Java

---

ITEM 79: AVOID EXCESSIVE SYNCHRONIZATION
321
In fact, there’s a better way to move the alien method invocations out of the
synchronized block. The libraries provide a 
concurrent collection
(Item 81)
known as 
CopyOnWriteArrayList
that is tailor-made for this purpose. This 
List
implementation is a variant of 
ArrayList
in which all modification operations are
implemented by making a fresh copy of the entire underlying array. Because the
internal array is never modified, iteration requires no locking and is very fast. For
most uses, the performance of 
CopyOnWriteArrayList
would be atrocious, but
it’s perfect for observer lists, which are rarely modified and often traversed.
The 
add
and 
addAll
methods of 
ObservableSet
need not be changed if the
list is modified to use 
CopyOnWriteArrayList
. Here is how the remainder of the
class looks. Notice that there is no explicit synchronization whatsoever:
// Thread-safe observable set with CopyOnWriteArrayList
private final List> observers = 
new CopyOnWriteArrayList<>();
public void addObserver(SetObserver observer) {
observers.add(observer);
}
public boolean removeObserver(SetObserver observer) {
return observers.remove(observer);
}
private void notifyElementAdded(E element) {
for (SetObserver observer : observers)
observer.added(this, element);
}
An alien method invoked outside of a synchronized region is known as an
open call
[Goetz06, 10.1.4]. Besides preventing failures, open calls can greatly
increase concurrency. An alien method might run for an arbitrarily long period. If
the alien method were invoked from a synchronized region, other threads would
be denied access to the protected resource unnecessarily.