jdk.util.concurrent.CopyOnWriteArraySet

Liking cljdoc? Tell your friends :D

Clojure only.

->copy-on-write-array-set
add
add-all
clear
contains
contains-all
empty?
equals
for-each
iterator
remove
remove-all
remove-if
retain-all
size
spliterator
to-array

A Set that uses an internal 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. It is thread-safe. 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 fast and cannot encounter interference from other threads. Iterators rely on unchanging snapshots of the array at the time the iterators were constructed.

Sample Usage. The following code sketch uses a copy-on-write set to maintain a set of Handler objects that perform some action upon state updates.

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(); for (Handler handler : handlers) handler.handle(); } }

This class is a member of the

Java Collections Framework.

A Set that uses an internal 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.
 It is thread-safe.
 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 fast and cannot encounter
     interference from other threads. Iterators rely on
     unchanging snapshots of the array at the time the iterators were
     constructed.


Sample Usage. The following code sketch uses a
copy-on-write set to maintain a set of Handler objects that
perform some action upon state updates.



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();
    for (Handler handler : handlers)
      handler.handle();
  }
}

This class is a member of the

Java Collections Framework.

jdk.util.concurrent.CopyOnWriteArraySet

->copy-on-write-array-setclj

addclj

add-allclj

clearclj

containsclj

contains-allclj

empty?clj

equalsclj

for-eachclj

iteratorclj

removeclj

remove-allclj

remove-ifclj

retain-allclj

sizeclj

spliteratorclj

to-arrayclj

->copy-on-write-array-set^clj

add^clj

add-all^clj

clear^clj

contains^clj

contains-all^clj

empty?^clj

equals^clj

for-each^clj

iterator^clj

remove^clj

remove-all^clj

remove-if^clj

retain-all^clj

size^clj

spliterator^clj

to-array^clj