Class CopyOnWriteArraySet

java.lang.Object
java.util.AbstractCollection
java.util.AbstractSet
EDU.oswego.cs.dl.util.concurrent.CopyOnWriteArraySet
All Implemented Interfaces:
Serializable, Cloneable, Iterable, Collection, Set
public class CopyOnWriteArraySet extends AbstractSet implements Cloneable, Serializable
This class implements a java.util.Set that uses a 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 fairly 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 Also: