diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentRefHashMap.java b/platform/util/src/com/intellij/util/containers/ConcurrentRefHashMap.java
index 0773a2e1d296..33690d579ece 100644
--- a/platform/util/src/com/intellij/util/containers/ConcurrentRefHashMap.java
+++ b/platform/util/src/com/intellij/util/containers/ConcurrentRefHashMap.java
@@ -126,7 +126,7 @@ abstract class ConcurrentRefHashMap<K, V> extends AbstractMap<K, V> implements C
 
   @Override
   public boolean isEmpty() {
-    return entrySet().isEmpty();
+    return myMap.isEmpty();
   }
 
   @Override
@@ -355,8 +355,9 @@ abstract class ConcurrentRefHashMap<K, V> extends AbstractMap<K, V> implements C
   @NotNull
   @Override
   public Set<Map.Entry<K, V>> entrySet() {
-    if (entrySet == null) entrySet = new EntrySet();
-    return entrySet;
+    Set<Entry<K, V>> es = entrySet;
+    if (es == null) entrySet = es = new EntrySet();
+    return es;
   }
 
   @Override
diff --git a/platform/util/src/com/intellij/util/containers/RefHashMap.java b/platform/util/src/com/intellij/util/containers/RefHashMap.java
index eeeac98406de..5d43b267e9a0 100644
--- a/platform/util/src/com/intellij/util/containers/RefHashMap.java
+++ b/platform/util/src/com/intellij/util/containers/RefHashMap.java
@@ -202,7 +202,7 @@ abstract class RefHashMap<K, V> extends AbstractMap<K, V> implements Map<K, V> {
 
   @Override
   public boolean isEmpty() {
-    return entrySet().isEmpty();
+    return myMap.isEmpty();
   }
 
   @Override
diff --git a/platform/util/src/com/intellij/util/containers/RefKeyRefValueHashMap.java b/platform/util/src/com/intellij/util/containers/RefKeyRefValueHashMap.java
index 6c35ab77279e..cd8ad304b4ce 100644
--- a/platform/util/src/com/intellij/util/containers/RefKeyRefValueHashMap.java
+++ b/platform/util/src/com/intellij/util/containers/RefKeyRefValueHashMap.java
@@ -21,11 +21,11 @@ import java.lang.ref.ReferenceQueue;
 import java.util.*;
 
 abstract class RefKeyRefValueHashMap<K,V> implements Map<K,V>{
-  private final RefHashMap<K, ValueReference<K,V>> myWeakKeyMap;
+  private final RefHashMap<K, ValueReference<K,V>> myMap;
   private final ReferenceQueue<V> myQueue = new ReferenceQueue<V>();
 
   RefKeyRefValueHashMap(@NotNull RefHashMap<K, ValueReference<K, V>> weakKeyMap) {
-    myWeakKeyMap = weakKeyMap;
+    myMap = weakKeyMap;
   }
 
   protected interface ValueReference<K, V> {
@@ -43,12 +43,12 @@ abstract class RefKeyRefValueHashMap<K,V> implements Map<K,V>{
 
   // returns true if some refs were tossed
   boolean processQueue() {
-    boolean processed = myWeakKeyMap.processQueue();
+    boolean processed = myMap.processQueue();
     while(true) {
       ValueReference<K,V> ref = (ValueReference<K, V>)myQueue.poll();
       if (ref == null) break;
       RefHashMap.Key<K> weakKey = ref.getKey();
-      myWeakKeyMap.removeKey(weakKey);
+      myMap.removeKey(weakKey);
       processed = true;
     }
     return processed;
@@ -56,23 +56,23 @@ abstract class RefKeyRefValueHashMap<K,V> implements Map<K,V>{
 
   @Override
   public V get(Object key) {
-    ValueReference<K,V> ref = myWeakKeyMap.get(key);
+    ValueReference<K,V> ref = myMap.get(key);
     return dereference(ref);
   }
 
   @Override
   public V put(K key, V value) {
     processQueue();
-    RefHashMap.Key<K> weakKey = myWeakKeyMap.createKey(key);
+    RefHashMap.Key<K> weakKey = myMap.createKey(key);
     ValueReference<K, V> reference = createValueReference(weakKey, value, myQueue);
-    ValueReference<K,V> oldRef = myWeakKeyMap.putKey(weakKey, reference);
+    ValueReference<K,V> oldRef = myMap.putKey(weakKey, reference);
     return dereference(oldRef);
   }
 
   @Override
   public V remove(Object key) {
     processQueue();
-    ValueReference<K,V> ref = myWeakKeyMap.remove(key);
+    ValueReference<K,V> ref = myMap.remove(key);
     return dereference(ref);
   }
 
@@ -83,18 +83,18 @@ abstract class RefKeyRefValueHashMap<K,V> implements Map<K,V>{
 
   @Override
   public void clear() {
-    myWeakKeyMap.clear();
+    myMap.clear();
     processQueue();
   }
 
   @Override
   public int size() {
-    return myWeakKeyMap.size(); //?
+    return myMap.size(); //?
   }
 
   @Override
   public boolean isEmpty() {
-    return myWeakKeyMap.isEmpty(); //?
+    return myMap.isEmpty();
   }
 
   @Override
@@ -110,14 +110,14 @@ abstract class RefKeyRefValueHashMap<K,V> implements Map<K,V>{
   @NotNull
   @Override
   public Set<K> keySet() {
-    return myWeakKeyMap.keySet();
+    return myMap.keySet();
   }
 
   @NotNull
   @Override
   public Collection<V> values() {
     List<V> result = new ArrayList<V>();
-    final Collection<ValueReference<K, V>> refs = myWeakKeyMap.values();
+    final Collection<ValueReference<K, V>> refs = myMap.values();
     for (ValueReference<K, V> ref : refs) {
       final V value = ref.get();
       if (value != null) {