package java.util.concurrent;
import java.util.*;
/**
* CopyOnWriteArraySets implement a java.util.Set that uses
* 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.
*
- Loops involving repeated element-by-element mutative operations
* are so expensive that they should generally be avoided.
*
- 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 synch
* lock while sending a message, and where traversals normally
* vastly overwhelm additions.
*
* class Handler { void handle(); ... }
*
* class X {
* private final CopyOnWriteArraySet handlers = new CopyOnWriteArraySet();
* 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())
* ((Handler)(it.next()).handle();
* }
* }
*
* [ Introduction to this package. ]
* @see CopyOnWriteArrayList
**/
public class CopyOnWriteArraySet extends AbstractSet
implements Cloneable, java.io.Serializable {
private final CopyOnWriteArrayList al;
/**
* Constructs an empty set
*/
public CopyOnWriteArraySet() {
al = new CopyOnWriteArrayList();
}
/**
* Constructs a set containing all of the elements of the specified
* Collection.
*/
public CopyOnWriteArraySet(Collection c) {
al = new CopyOnWriteArrayList();
al.addAllAbsent(c);
}
public int size() { return al.size(); }
public boolean isEmpty() { return al.isEmpty(); }
public boolean contains(Object o) { return al.contains(o); }
public Object[] toArray() { return al.toArray(); }
public T[] toArray(T[] a) { return al.toArray(a); }
public void clear() { al.clear(); }
public Iterator iterator() { return al.iterator(); }
public boolean remove(Object o) { return al.remove(o); }
public boolean add(E o) { return al.addIfAbsent(o); }
public boolean containsAll(Collection c) { return al.containsAll(c); }
public boolean addAll(Collection c) { return al.addAllAbsent(c) > 0; }
public boolean removeAll(Collection c) { return al.removeAll(c); }
public boolean retainAll(Collection c) { return al.retainAll(c); }
}