test/java/util/concurrent/locks/ReentrantReadWriteLock/RWMap.java

Print this page




  40  * This is an incomplete implementation of a wrapper class
  41  * that places read-write locks around unsynchronized Maps.
  42  * Exists as a sample input for MapLoops test.
  43  */
  44 
  45 public class RWMap implements Map {
  46     private final Map m;
  47     private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
  48 
  49     public RWMap(Map m) {
  50         if (m == null)
  51             throw new NullPointerException();
  52         this.m = m;
  53     }
  54 
  55     public RWMap() {
  56         this(new TreeMap()); // use TreeMap by default
  57     }
  58 
  59     public int size() {
  60         rwl.readLock().lock(); try {return m.size();} finally { rwl.readLock().unlock(); }


  61     }
  62     public boolean isEmpty(){
  63         rwl.readLock().lock(); try {return m.isEmpty();} finally { rwl.readLock().unlock(); }



  64     }
  65 
  66     public Object get(Object key) {
  67         rwl.readLock().lock(); try {return m.get(key);} finally { rwl.readLock().unlock(); }


  68     }
  69 
  70     public boolean containsKey(Object key) {
  71         rwl.readLock().lock(); try {return m.containsKey(key);} finally { rwl.readLock().unlock(); }


  72     }
  73     public boolean containsValue(Object value){
  74         rwl.readLock().lock(); try {return m.containsValue(value);} finally { rwl.readLock().unlock(); }



  75     }
  76 
  77 
  78     public Set keySet() { // Not implemented
  79         return null;
  80     }
  81 
  82     public Set entrySet() { // Not implemented
  83         return null;
  84     }
  85 
  86     public Collection values() { // Not implemented
  87         return null;
  88     }
  89 
  90     public boolean equals(Object o) {
  91         rwl.readLock().lock(); try {return m.equals(o);} finally { rwl.readLock().unlock(); }


  92     }

  93     public int hashCode() {
  94         rwl.readLock().lock(); try {return m.hashCode();} finally { rwl.readLock().unlock(); }


  95     }

  96     public String toString() {
  97         rwl.readLock().lock(); try {return m.toString();} finally { rwl.readLock().unlock(); }


  98     }
  99 
 100 
 101 
 102     public Object put(Object key, Object value) {
 103         rwl.writeLock().lock(); try {return m.put(key, value);} finally { rwl.writeLock().unlock(); }


 104     }

 105     public Object remove(Object key) {
 106         rwl.writeLock().lock(); try {return m.remove(key);} finally { rwl.writeLock().unlock(); }


 107     }

 108     public void putAll(Map map) {
 109         rwl.writeLock().lock(); try {m.putAll(map);} finally { rwl.writeLock().unlock(); }


 110     }

 111     public void clear() {
 112         rwl.writeLock().lock(); try {m.clear();} finally { rwl.writeLock().unlock(); }


 113     }
 114 
 115 }


  40  * This is an incomplete implementation of a wrapper class
  41  * that places read-write locks around unsynchronized Maps.
  42  * Exists as a sample input for MapLoops test.
  43  */
  44 
  45 public class RWMap implements Map {
  46     private final Map m;
  47     private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
  48 
  49     public RWMap(Map m) {
  50         if (m == null)
  51             throw new NullPointerException();
  52         this.m = m;
  53     }
  54 
  55     public RWMap() {
  56         this(new TreeMap()); // use TreeMap by default
  57     }
  58 
  59     public int size() {
  60         rwl.readLock().lock();
  61         try { return m.size(); }
  62         finally { rwl.readLock().unlock(); }
  63     }
  64 
  65     public boolean isEmpty() {
  66         rwl.readLock().lock();
  67         try { return m.isEmpty(); }
  68         finally { rwl.readLock().unlock(); }
  69     }
  70 
  71     public Object get(Object key) {
  72         rwl.readLock().lock();
  73         try { return m.get(key); }
  74         finally { rwl.readLock().unlock(); }
  75     }
  76 
  77     public boolean containsKey(Object key) {
  78         rwl.readLock().lock();
  79         try { return m.containsKey(key); }
  80         finally { rwl.readLock().unlock(); }
  81     }
  82 
  83     public boolean containsValue(Object value) {
  84         rwl.readLock().lock();
  85         try { return m.containsValue(value); }
  86         finally { rwl.readLock().unlock(); }
  87     }
  88 
  89 
  90     public Set keySet() { // Not implemented
  91         return null;
  92     }
  93 
  94     public Set entrySet() { // Not implemented
  95         return null;
  96     }
  97 
  98     public Collection values() { // Not implemented
  99         return null;
 100     }
 101 
 102     public boolean equals(Object o) {
 103         rwl.readLock().lock();
 104         try { return m.equals(o); }
 105         finally { rwl.readLock().unlock(); }
 106     }
 107 
 108     public int hashCode() {
 109         rwl.readLock().lock();
 110         try { return m.hashCode(); }
 111         finally { rwl.readLock().unlock(); }
 112     }
 113 
 114     public String toString() {
 115         rwl.readLock().lock();
 116         try { return m.toString(); }
 117         finally { rwl.readLock().unlock(); }
 118     }
 119 


 120     public Object put(Object key, Object value) {
 121         rwl.writeLock().lock();
 122         try { return m.put(key, value); }
 123         finally { rwl.writeLock().unlock(); }
 124     }
 125 
 126     public Object remove(Object key) {
 127         rwl.writeLock().lock();
 128         try { return m.remove(key); }
 129         finally { rwl.writeLock().unlock(); }
 130     }
 131 
 132     public void putAll(Map map) {
 133         rwl.writeLock().lock();
 134         try { m.putAll(map); }
 135         finally { rwl.writeLock().unlock(); }
 136     }
 137 
 138     public void clear() {
 139         rwl.writeLock().lock();
 140         try { m.clear(); }
 141         finally { rwl.writeLock().unlock(); }
 142     }
 143 
 144 }