A {@link java.util.Set} that uses {@link
java.util.concurrent.CopyOnWriteArrayList} for all of its
operations. Thus, it shares the same basic properties:
- It is best suited for applications in which set sizes generally
stay small, read-only operations
vastly outnumber mutative operations, and you need
to prevent interference among threads during traversal.
- Mutative operations(add, set, remove, etc) are expensive
since they usually entail copying the entire underlying array.
- Iterators do not support the mutative remove operation
- Traversal via iterators is very fast and cannot ever encounter
interference from other threads. Iterators rely on
unchanging snapshots of the array at the time the iterators were
constructed.
Sample Usage. Probably the main application
of copy-on-write sets are classes that maintain
sets of Handler objects
that must be multicasted to upon an update command. This
is a classic case where you do not want to be holding a
lock while sending a message, and where traversals normally
vastly overwhelm additions.
class Handler { void handle(); ... }
class X {
private final CopyOnWriteArraySet<Handler> handlers = new CopyOnWriteArraySet<Handler>();
public void addHandler(Handler h) { handlers.add(h); }
private long internalState;
private synchronized void changeState() { internalState = ...; }
public void update() {
changeState();
Iterator it = handlers.iterator();
while (it.hasNext())
it.next().handle();
}
}
|
