jdk-sandbox: comparison jdk/src/share/classes/java/lang/invoke/MethodType.java

equal deleted inserted replaced

-:9b6ad451b521
+:e0b8c923f35d
 package java.lang.invoke;
 import sun.invoke.util.Wrapper;
 import java.lang.ref.WeakReference;
+import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ConcurrentHashMap;
 import sun.invoke.util.BytecodeDescriptor;
 import static java.lang.invoke.MethodHandleStatics.*;
 import sun.invoke.util.VerifyType;
 /**
 private static IndexOutOfBoundsException newIndexOutOfBoundsException(Object num) {
 if (num instanceof Integer)  num = "bad index: "+num;
 return new IndexOutOfBoundsException(num.toString());
 }
-static final WeakInternSet internTable = new WeakInternSet();
+static final ConcurrentWeakInternSet<MethodType> internTable = new ConcurrentWeakInternSet<>();
 static final Class<?>[] NO_PTYPES = {};
 /**
 * Finds or creates an instance of the given method type.
 // Verify all operands, and make sure ptypes is unshared:
 return methodType(rtype, ptypes);
 }
 /**
-* Weak intern set based on implementation of the <tt>HashSet</tt> and
+* Simple implementation of weak concurrent intern set.
-* <tt>WeakHashMap</tt>, with <em>weak values</em>.  Note: <tt>null</tt>
-* values will yield <tt>NullPointerException</tt>
-* Refer to implementation of WeakInternSet for details.
 *
-* @see         java.util.HashMap
+* @param <T> interned type
-* @see         java.util.HashSet
+*/
-* @see         java.util.WeakHashMap
+private static class ConcurrentWeakInternSet<T> {
-* @see         java.lang.ref.WeakReference
-*/
+private final ConcurrentMap<WeakEntry<T>, WeakEntry<T>> map;
-private static class WeakInternSet {
+private final ReferenceQueue<T> stale;
-// The default initial capacity -- MUST be a power of two.
-private static final int DEFAULT_INITIAL_CAPACITY = 16;
+public ConcurrentWeakInternSet() {
+this.map = new ConcurrentHashMap<>();
-// The maximum capacity, used if a higher value is implicitly specified
+this.stale = new ReferenceQueue<>();
-// by either of the constructors with arguments.
-// MUST be a power of two <= 1<<30.
-private static final int MAXIMUM_CAPACITY = 1 << 30;
-// The load factor used when none specified in constructor.
-private static final float DEFAULT_LOAD_FACTOR = 0.75f;
-// The table, resized as necessary. Length MUST Always be a power of two.
-private Entry[] table;
-// The number of entries contained in this set.
-private int size;
-// The next size value at which to resize (capacity * load factor).
-private int threshold;
-// The load factor for the hash table.
-private final float loadFactor;
-// Reference queue for cleared WeakEntries
-private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
-private Entry[] newTable(int n) {
-return new Entry[n];
 }
 /**
-* Constructs a new, empty <tt>WeakInternSet</tt> with the default initial
+* Get the existing interned element.
-* capacity (16) and load factor (0.75).
+* This method returns null if no element is interned.
+*
+* @param elem element to look up
+* @return the interned element
 */
-WeakInternSet() {
+public T get(T elem) {
-this.loadFactor = DEFAULT_LOAD_FACTOR;
+if (elem == null) throw new NullPointerException();
-threshold = DEFAULT_INITIAL_CAPACITY;
+expungeStaleElements();
-table = newTable(DEFAULT_INITIAL_CAPACITY);
-}
+WeakEntry<T> value = map.get(new WeakEntry<>(elem));
+if (value != null) {
-/**
+T res = value.get();
-* Applies a supplemental hash function to a given hashCode, which
+if (res != null) {
-* defends against poor quality hash functions.  This is critical
+return res;
-* because hashing uses power-of-two length hash tables, that
-* otherwise encounter collisions for hashCodes that do not differ
-* in lower bits.
-* @param h preliminary hash code value
-* @return supplemental hash code value
-*/
-private static int hash(int h) {
-// This function ensures that hashCodes that differ only by
-// constant multiples at each bit position have a bounded
-// number of collisions (approximately 8 at default load factor).
-h ^= (h >>> 20) ^ (h >>> 12);
-return h ^ (h >>> 7) ^ (h >>> 4);
-}
-/**
-* Checks for equality of non-null reference x and possibly-null y.  By
-* default uses Object.equals.
-* @param x first object to compare
-* @param y second object to compare
-* @return <tt>true</tt> if objects are equal
-*/
-private static boolean eq(Object x, Object y) {
-return x == y || x.equals(y);
-}
-/**
-* Returns index for hash code h.
-* @param h      raw hash code
-* @param length length of table (power of 2)
-* @return index in table
-*/
-private static int indexFor(int h, int length) {
-return h & (length-1);
-}
-/**
-* Expunges stale entries from the table.
-*/
-private void expungeStaleEntries() {
-for (Object x; (x = queue.poll()) != null; ) {
-synchronized (queue) {
-Entry entry = (Entry) x;
-int i = indexFor(entry.hash, table.length);
-Entry prev = table[i];
-Entry p = prev;
-while (p != null) {
-Entry next = p.next;
-if (p == entry) {
-if (prev == entry)
-table[i] = next;
-else
-prev.next = next;
-entry.next = null;
-size--;
-break;
-}
-prev = p;
-p = next;
-}
 }
 }
+return null;
 }
 /**
-* Returns the table after first expunging stale entries.
+* Interns the element.
-* @return an expunged hash table
+* Always returns non-null element, matching the one in the intern set.
+* Under the race against another add(), it can return <i>different</i>
+* element, if another thread beats us to interning it.
+*
+* @param elem element to add
+* @return element that was actually added
 */
-private Entry[] getTable() {
+public T add(T elem) {
-expungeStaleEntries();
+if (elem == null) throw new NullPointerException();
-return table;
-}
+// Playing double race here, and so spinloop is required.
+// First race is with two concurrent updaters.
-/**
+// Second race is with GC purging weak ref under our feet.
-* Returns the entry to which the specified value is mapped,
+// Hopefully, we almost always end up with a single pass.
-* or {@code null} if this set contains no entry for the value.
+T interned;
-*
+WeakEntry<T> e = new WeakEntry<>(elem, stale);
-* <p>More formally, if this set contains an entry for value
+do {
-* {@code entry} to a value {@code value} such that
+expungeStaleElements();
-* {@code entry.equals(value)}, then this method returns {@code entry};
+WeakEntry<T> exist = map.putIfAbsent(e, e);
-* otherwise it returns {@code null}.
+interned = (exist == null) ? elem : exist.get();
-*
+} while (interned == null);
-* @param value value to search for in set
+return interned;
-* @return interned value if in set, otherwise <tt>null</tt>
+}
-*/
-synchronized MethodType get(MethodType value) {
+private void expungeStaleElements() {
-int h = hash(value.hashCode());
+Reference<? extends T> reference;
-Entry[] tab = getTable();
+while ((reference = stale.poll()) != null) {
-int index = indexFor(h, tab.length);
+map.remove(reference);
-Entry e = tab[index];
-MethodType g;
-while (e != null) {
-if (e.hash == h && eq(value, g = e.get()))
-return g;
-e = e.next;
 }
-return null;
+}
-}
+private static class WeakEntry<T> extends WeakReference<T> {
-/**
-* Attempts to add the specified value to the set and returns same value.
+public final int hashcode;
-* If the set previously contained an entry for this value, the old
-* value is left untouched and returned as the result.
+public WeakEntry(T key, ReferenceQueue<T> queue) {
-*
+super(key, queue);
-* @param value value to be added
+hashcode = key.hashCode();
-* @return the previous entry associated with <tt>value</tt>, or
+}
-*         <tt>value</tt> if there was no previous entry found
-*/
+public WeakEntry(T key) {
-synchronized MethodType add(MethodType value) {
+super(key);
-int h = hash(value.hashCode());
+hashcode = key.hashCode();
-Entry[] tab = getTable();
+}
-int i = indexFor(h, tab.length);
-MethodType g;
+@Override
-for (Entry e = tab[i]; e != null; e = e.next) {
+public boolean equals(Object obj) {
-if (h == e.hash && eq(value, g = e.get())) {
+if (obj instanceof WeakEntry) {
-return g;
+Object that = ((WeakEntry) obj).get();
+Object mine = get();
+return (that == null || mine == null) ? (this == obj) : mine.equals(that);
 }
+return false;
 }
-Entry e = tab[i];
-tab[i] = new Entry(value, queue, h, e);
+@Override
-if (++size >= threshold)
+public int hashCode() {
-resize(tab.length * 2);
+return hashcode;
-return value;
-}
-/**
-* Rehashes the contents of this set into a new array with a
-* larger capacity.  This method is called automatically when the
-* number of keys in this set reaches its threshold.
-*
-* If current capacity is MAXIMUM_CAPACITY, this method does not
-* resize the set, but sets threshold to Integer.MAX_VALUE.
-* This has the effect of preventing future calls.
-*
-* @param newCapacity the new capacity, MUST be a power of two;
-*        must be greater than current capacity unless current
-*        capacity is MAXIMUM_CAPACITY (in which case value
-*        is irrelevant)
-*/
-private void resize(int newCapacity) {
-Entry[] oldTable = getTable();
-int oldCapacity = oldTable.length;
-if (oldCapacity == MAXIMUM_CAPACITY) {
-threshold = Integer.MAX_VALUE;
-return;
 }
-Entry[] newTable = newTable(newCapacity);
+}
-transfer(oldTable, newTable);
+}
-table = newTable;
-/*
-* 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.
-*/
-if (size >= threshold / 2) {
-threshold = (int)(newCapacity * loadFactor);
-} else {
-expungeStaleEntries();
-transfer(newTable, oldTable);
-table = oldTable;
-}
-}
-/**
-* Transfers all entries from src to dest tables
-* @param src  original table
-* @param dest new table
-*/
-private void transfer(Entry[] src, Entry[] dest) {
-for (int j = 0; j < src.length; ++j) {
-Entry e = src[j];
-src[j] = null;
-while (e != null) {
-Entry next = e.next;
-MethodType key = e.get();
-if (key == null) {
-e.next = null;  // Help GC
-size--;
-} else {
-int i = indexFor(e.hash, dest.length);
-e.next = dest[i];
-dest[i] = e;
-}
-e = next;
-}
-}
-}
-/**
-* The entries in this hash table extend WeakReference, using its main ref
-* field as the key.
-*/
-private static class Entry extends WeakReference<MethodType> {
-final int hash;
-Entry next;
-/**
-* Creates new entry.
-*/
-Entry(MethodType key,
-ReferenceQueue<Object> queue,
-int hash, Entry next) {
-super(key, queue);
-this.hash  = hash;
-this.next  = next;
-}
-}
-}
 }

changeset 18180	e0b8c923f35d
parent 13610	28122b96858e
child 18569	0e46c17766b7