Mercurial > hg > blitz_stable

comparison src/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArraySet.java @ 0:3dc0c5604566

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial checkin of blitz 2.0 fcs - no installer yet.
author Dan Creswell <dan.creswell@gmail.com>
date Sat, 21 Mar 2009 11:00:06 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:3dc0c5604566
1 /*
2 File: CopyOnWriteArraySet.java
3
4 Originally written by Doug Lea and released into the public domain.
5 This may be used for any purposes whatsoever without acknowledgment.
6 Thanks for the assistance and support of Sun Microsystems Labs,
7 and everyone contributing, testing, and using this code.
8
9 History:
10 Date Who What
11 22Jun1998 dl Create public version
12 */
13
14 package EDU.oswego.cs.dl.util.concurrent;
15 import java.util.*;
16
17 /**
18 * This class implements a java.util.Set that uses a
19 * CopyOnWriteArrayList for all of its operations.
20 * Thus, it shares the same basic properties:
21 * <ul>
22 * <li> It is best suited for applications in which set sizes generally
23 * stay small, read-only operations
24 * vastly outnumber mutative operations, and you need
25 * to prevent interference among threads during traversal.
26 * <li> Mutative operations(add, set, remove, etc) are fairly expensive
27 * since they usually entail copying the entire underlying array.
28 * <li> Loops involving repeated element-by-element mutative operations
29 * are so expensive that they should generally be avoided.
30 * <li> Iterators do not support the mutative remove operation
31 * <li> Traversal via iterators is very fast and cannot ever encounter
32 * interference from other threads. Iterators rely on
33 * unchanging snapshots of the array at the time the iterators were
34 * constructed
35 * </ul>
36 * <p>
37 * <b>Sample Usage.</b> Probably the main application
38 * of copy-on-write sets are classes that maintain
39 * sets of Handler objects
40 * that must be multicasted to upon an update command. This
41 * is a classic case where you do not want to be holding a synch
42 * lock while sending a message, and where traversals normally
43 * vastly overwhelm additions.
44 * <pre>
45 * class Handler { void handle(); ... }
46 *
47 * class X {
48 * private final CopyOnWriteArraySet handlers = new CopyOnWriteArraySet();
49 * public void addHandler(Handler h) { handlers.add(h); }
50 *
51 * private long internalState;
52 * private synchronized void changeState() { internalState = ...; }
53 *
54 * public void update() {
55 * changeState();
56 * Iterator it = handlers.iterator();
57 * while (it.hasNext())
58 * ((Handler)(it.next()).handle();
59 * }
60 * }
61 * </pre>
62 * <p>[<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
63 * @see CopyOnWriteArrayList
64 **/
65
66
67 public class CopyOnWriteArraySet extends AbstractSet implements Cloneable, java.io.Serializable {
68
69 protected final CopyOnWriteArrayList al;
70
71 /**
72 * Constructs an empty set
73 */
74 public CopyOnWriteArraySet() {
75 al = new CopyOnWriteArrayList();
76 }
77
78 /**
79 * Constructs a set containing all of the elements of the specified
80 * Collection.
81 */
82 public CopyOnWriteArraySet(Collection c) {
83 al = new CopyOnWriteArrayList();
84 al.addAllAbsent(c);
85 }
86
87
88 public int size() { return al.size(); }
89 public boolean isEmpty() { return al.isEmpty(); }
90 public boolean contains(Object o) { return al.contains(o); }
91 public Object[] toArray() { return al.toArray(); }
92 public Object[] toArray(Object[] a) { return al.toArray(a); }
93 public void clear() { al.clear(); }
94 public Iterator iterator() { return al.iterator(); }
95 public boolean remove(Object o) { return al.remove(o); }
96 public boolean containsAll(Collection c) { return al.containsAll(c); }
97 public boolean addAll(Collection c) { return al.addAllAbsent(c) > 0; }
98 public boolean removeAll(Collection c) { return al.removeAll(c); }
99 public boolean retainAll(Collection c) { return al.retainAll(c); }
100 public boolean add(Object o) { return al.addIfAbsent(o); }
101
102 }