• 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();
    }
 }