ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/loops/RWMap.java
(Generate patch)

Comparing jsr166/src/test/loops/RWMap.java (file contents):
Revision 1.2 by dl, Mon May 9 19:33:30 2005 UTC vs.
Revision 1.6 by jsr166, Sat Oct 16 16:22:57 2010 UTC

# Line 13 | Line 13 | import java.util.concurrent.locks.*;
13   * that places read-write locks around unsynchronized Maps.
14   * Exists as a sample input for MapLoops test.
15   */
16 –
16   public class RWMap implements Map {
17      private final Map m;
18      private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
19 <    
19 >
20      public RWMap(Map m) {
21          if (m == null)
22              throw new NullPointerException();
23          this.m = m;
24      }
25  
26 <    public RWMap() {
26 >    public RWMap() {
27          this(new TreeMap()); // use TreeMap by default
28 +        //        this(new IdentityHashMap());
29      }
30  
31      public int size() {
32 <        rwl.readLock().lock(); try {return m.size();} finally { rwl.readLock().unlock(); }
32 >        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
33 >        l.lock();
34 >        try { return m.size(); }
35 >        finally { l.unlock(); }
36      }
37 <    public boolean isEmpty(){
38 <        rwl.readLock().lock(); try {return m.isEmpty();} finally { rwl.readLock().unlock(); }
37 >
38 >    public boolean isEmpty() {
39 >        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
40 >        l.lock();
41 >        try { return m.isEmpty(); }
42 >        finally { l.unlock(); }
43      }
44  
45      public Object get(Object key) {
46 <        rwl.readLock().lock(); try {return m.get(key);} finally { rwl.readLock().unlock(); }
46 >        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
47 >        l.lock();
48 >        try { return m.get(key); }
49 >        finally { l.unlock(); }
50      }
51  
52      public boolean containsKey(Object key) {
53 <        rwl.readLock().lock(); try {return m.containsKey(key);} finally { rwl.readLock().unlock(); }
54 <    }
55 <    public boolean containsValue(Object value){
56 <        rwl.readLock().lock(); try {return m.containsValue(value);} finally { rwl.readLock().unlock(); }
53 >        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
54 >        l.lock();
55 >        try { return m.containsKey(key); }
56 >        finally { l.unlock(); }
57      }
58  
59 +    public boolean containsValue(Object value) {
60 +        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
61 +        l.lock();
62 +        try { return m.containsValue(value); }
63 +        finally { l.unlock(); }
64 +    }
65  
66      public Set keySet() { // Not implemented
67          return m.keySet();
68      }
69 <    
69 >
70      public Set entrySet() { // Not implemented
71          return m.entrySet();
72      }
73 <    
73 >
74      public Collection values() { // Not implemented
75          return m.values();
76      }
77 <    
77 >
78      public boolean equals(Object o) {
79 <        rwl.readLock().lock(); try {return m.equals(o);} finally { rwl.readLock().unlock(); }
79 >        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
80 >        l.lock();
81 >        try { return m.equals(o); }
82 >        finally { l.unlock(); }
83      }
84 +
85      public int hashCode() {
86 <        rwl.readLock().lock(); try {return m.hashCode();} finally { rwl.readLock().unlock(); }
86 >        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
87 >        l.lock();
88 >        try { return m.hashCode(); }
89 >        finally { l.unlock(); }
90      }
91 +
92      public String toString() {
93 <        rwl.readLock().lock(); try {return m.toString();} finally { rwl.readLock().unlock(); }
93 >        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
94 >        l.lock();
95 >        try { return m.toString(); }
96 >        finally { l.unlock(); }
97      }
98  
72 –
73 –
99      public Object put(Object key, Object value) {
100 <        rwl.writeLock().lock(); try {return m.put(key, value);} finally { rwl.writeLock().unlock(); }
100 >        ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
101 >        l.lock();
102 >        try { return m.put(key, value); }
103 >        finally { l.unlock(); }
104      }
105 +
106      public Object remove(Object key) {
107 <        rwl.writeLock().lock(); try {return m.remove(key);} finally { rwl.writeLock().unlock(); }
107 >        ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
108 >        l.lock();
109 >        try { return m.remove(key); }
110 >        finally { l.unlock(); }
111      }
112 +
113      public void putAll(Map map) {
114 <        rwl.writeLock().lock(); try {m.putAll(map);} finally { rwl.writeLock().unlock(); }
114 >        ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
115 >        l.lock();
116 >        try { m.putAll(map); }
117 >        finally { l.unlock(); }
118      }
119 +
120      public void clear() {
121 <        rwl.writeLock().lock(); try {m.clear();} finally { rwl.writeLock().unlock(); }
121 >        ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
122 >        l.lock();
123 >        try { m.clear(); }
124 >        finally { l.unlock(); }
125      }
126 <    
126 >
127   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines