8023310: Thread contention in the method Beans.IsDesignTime()

Reviewed-by: art, sfriberg

src/share/classes/java/beans/ThreadGroupContext.java

@@ -41,24 +41,20 @@ import java.util.WeakHashMap;
  */
 final class ThreadGroupContext {
 
-    private static final WeakIdentityMap<ThreadGroupContext> contexts = new WeakIdentityMap<>();
+    private static final WeakIdentityMap<ThreadGroupContext> contexts = new WeakIdentityMap<ThreadGroupContext>() {
+        protected ThreadGroupContext create(Object key) {
+            return new ThreadGroupContext();
+        }
+    };
 
     /**
-     * Returns the appropriate {@code AppContext} for the caller,
+     * Returns the appropriate {@code ThreadGroupContext} for the caller,
      * as determined by its {@code ThreadGroup}.
      *
      * @return  the application-dependent context
      */
     static ThreadGroupContext getContext() {
-        ThreadGroup group = Thread.currentThread().getThreadGroup();
-        synchronized (contexts) {
-            ThreadGroupContext context = contexts.get(group);
-            if (context == null) {
-                context = new ThreadGroupContext();
-                contexts.put(group, context);
-            }
-            return context;
-        }
+        return contexts.get(Thread.currentThread().getThreadGroup());
     }
 
     private volatile boolean isDesignTime;

src/share/classes/java/beans/WeakIdentityMap.java

@@ -33,18 +33,22 @@ import java.lang.ref.WeakReference;
  * and reference-equality in place of object-equality to compare them.
  * An entry will automatically be removed when its key is no longer
  * in ordinary use.  Both null values and the null key are supported.
+ * This class does not require additional synchronization.
+ * A thread-safety is provided by a fragile combination
+ * of synchronized blocks and volatile fields.
+ * Be very careful during editing!
  *
  * @see java.util.IdentityHashMap
  * @see java.util.WeakHashMap
  */
-final class WeakIdentityMap<T> {
+abstract class WeakIdentityMap<T> {
 
     private static final int MAXIMUM_CAPACITY = 1 << 30; // it MUST be a power of two
     private static final Object NULL = new Object(); // special object for null key
 
     private final ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
 
-    private Entry<T>[] table = newTable(1<<3); // table's length MUST be a power of two
+    private volatile Entry<T>[] table = newTable(1<<3); // table's length MUST be a power of two
     private int threshold = 6; // the next size value at which to resize
     private int size = 0; // the number of key-value mappings
 
@@ -54,29 +58,25 @@ final class WeakIdentityMap<T> {
             key = NULL;
         }
         int hash = key.hashCode();
-        int index = getIndex(this.table, hash);
-        for (Entry<T> entry = this.table[index]; entry != null; entry = entry.next) {
+        Entry<T>[] table = this.table;
+        // unsynchronized search improves performance
+        // the null value does not mean that there are no needed entry
+        int index = getIndex(table, hash);
+        for (Entry<T> entry = table[index]; entry != null; entry = entry.next) {
             if (entry.isMatched(key, hash)) {
                 return entry.value;
             }
         }
-        return null;
-    }
-
-    public T put(Object key, T value) {
-        removeStaleEntries();
-        if (key == null) {
-            key = NULL;
-        }
-        int hash = key.hashCode();
-        int index = getIndex(this.table, hash);
+        synchronized (NULL) {
+            // synchronized search improves stability
+            // we must create and add new value if there are no needed entry
+            index = getIndex(this.table, hash);
             for (Entry<T> entry = this.table[index]; entry != null; entry = entry.next) {
                 if (entry.isMatched(key, hash)) {
-                T oldValue = entry.value;
-                entry.value = value;
-                return oldValue;
+                    return entry.value;
                 }
             }
+            T value = create(key);
             this.table[index] = new Entry<T>(key, hash, value, this.queue, this.table[index]);
             if (++this.size >= this.threshold) {
                 if (this.table.length == MAXIMUM_CAPACITY) {
@@ -84,9 +84,8 @@ final class WeakIdentityMap<T> {
                 }
                 else {
                     removeStaleEntries();
-                Entry<T>[] table = newTable(this.table.length * 2);
+                    table = newTable(this.table.length * 2);
                     transfer(this.table, table);
-
                     // If ignoring null elements and processing ref queue caused massive
                     // shrinkage, then restore old table.  This should be rare, but avoids
                     // unbounded expansion of garbage-filled tables.
@@ -99,11 +98,17 @@ final class WeakIdentityMap<T> {
                     }
                 }
             }
-        return null;
+            return value;
+        }
     }
 
+    protected abstract T create(Object key);
+
     private void removeStaleEntries() {
-        for (Object ref = this.queue.poll(); ref != null; ref = this.queue.poll()) {
+        Object ref = this.queue.poll();
+        if (ref != null) {
+            synchronized (NULL) {
+                do {
                     @SuppressWarnings("unchecked")
                     Entry<T> entry = (Entry<T>) ref;
                     int index = getIndex(this.table, entry.hash);
@@ -127,6 +132,10 @@ final class WeakIdentityMap<T> {
                         prev = current;
                         current = next;
                     }
+                    ref = this.queue.poll();
+                }
+                while (ref != null);
+            }
         }
     }
 
@@ -164,8 +173,8 @@ final class WeakIdentityMap<T> {
 
     private static class Entry<T> extends WeakReference<Object> {
         private final int hash;
-        private T value;
-        private Entry<T> next;
+        private volatile T value;
+        private volatile Entry<T> next;
 
         Entry(Object key, int hash, T value, ReferenceQueue<Object> queue, Entry<T> next) {
             super(key, queue);