Java tutorial
/* * Copyright 2004 Brian S O'Neill * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ //revised from cojen import java.lang.ref.Reference; import java.lang.ref.ReferenceQueue; import java.lang.ref.WeakReference; import java.util.AbstractSet; import java.util.Iterator; import java.util.NoSuchElementException; /** * A thread-safe Set that manages canonical objects: sharable objects that are * typically immutable. Call the {@link #put put} method for supplying the * WeakCanonicalSet with candidate canonical instances. * <p> * Objects that do not customize the hashCode and equals methods don't make * sense to be canonicalized because each instance will be considered unique. * The object returned from the {@link #put put} method will always be the same * as the one passed in. * * @author Brian S O'Neill */ public class WeakCanonicalSet<T> extends AbstractSet<T> { private Entry<T>[] table; private int count; private int threshold; private final float loadFactor; private final ReferenceQueue<T> queue; public WeakCanonicalSet() { final int initialCapacity = 101; final float loadFactor = 0.75f; this.loadFactor = loadFactor; this.table = new Entry[initialCapacity]; this.threshold = (int) (initialCapacity * loadFactor); this.queue = new ReferenceQueue<T>(); } /** * Pass in a candidate canonical object and get a unique instance from this * set. The returned object will always be of the same type as that passed * in. If the object passed in does not equal any object currently in the * set, it will be added to the set, becoming canonical. * * @param obj candidate canonical object; null is also accepted */ public synchronized <U extends T> U put(U obj) { // This implementation is based on the WeakIdentityMap.put method. if (obj == null) { return null; } Entry<T>[] tab = this.table; // Cleanup after cleared References. { ReferenceQueue queue = this.queue; Reference ref; while ((ref = queue.poll()) != null) { // Since buckets are single-linked, traverse entire list and // cleanup all cleared references in it. int index = (((Entry) ref).hash & 0x7fffffff) % tab.length; for (Entry<T> e = tab[index], prev = null; e != null; e = e.next) { if (e.get() == null) { if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else { prev = e; } } } } int hash = hashCode(obj); int index = (hash & 0x7fffffff) % tab.length; for (Entry<T> e = tab[index], prev = null; e != null; e = e.next) { T iobj = e.get(); if (iobj == null) { // Clean up after a cleared Reference. if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && obj.getClass() == iobj.getClass() && equals(obj, iobj)) { // Found canonical instance. return (U) iobj; } else { prev = e; } } if (this.count >= this.threshold) { // Rehash the table if the threshold is exceeded. rehash(); tab = this.table; index = (hash & 0x7fffffff) % tab.length; } // Create a new entry. tab[index] = new Entry<T>(obj, this.queue, hash, tab[index]); this.count++; return obj; } public Iterator<T> iterator() { return new SetIterator(); } public int size() { return this.count; } public synchronized boolean contains(Object obj) { if (obj == null) { return false; } Entry<T>[] tab = this.table; int hash = hashCode(obj); int index = (hash & 0x7fffffff) % tab.length; for (Entry<T> e = tab[index], prev = null; e != null; e = e.next) { Object iobj = e.get(); if (iobj == null) { // Clean up after a cleared Reference. if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } this.count--; } else if (e.hash == hash && obj.getClass() == iobj.getClass() && equals(obj, iobj)) { // Found canonical instance. return true; } else { prev = e; } } return false; } protected int hashCode(Object obj) { return obj.hashCode(); } protected boolean equals(Object a, Object b) { return a.equals(b); } private void rehash() { int oldCapacity = this.table.length; Entry<T>[] tab = this.table; int newCapacity = oldCapacity * 2 + 1; Entry<T>[] newTab = new Entry[newCapacity]; this.threshold = (int) (newCapacity * this.loadFactor); this.table = newTab; for (int i = oldCapacity; i-- > 0;) { for (Entry<T> old = tab[i]; old != null;) { Entry<T> e = old; old = old.next; // Only copy entry if it hasn't been cleared. if (e.get() == null) { this.count--; } else { int index = (e.hash & 0x7fffffff) % newCapacity; e.next = newTab[index]; newTab[index] = e; } } } } private static class Entry<T> extends WeakReference<T> { int hash; Entry<T> next; Entry(T canonical, ReferenceQueue<T> queue, int hash, Entry<T> next) { super(canonical, queue); this.hash = hash; this.next = next; } } private class SetIterator implements Iterator<T> { private final Entry<T>[] table; private int index; // To ensure that the iterator doesn't return cleared entries, keep a // hard reference to the canonical object. Its existence will prevent // the weak reference from being cleared. private T entryCanonical; private Entry<T> entry; SetIterator() { this.table = WeakCanonicalSet.this.table; this.index = table.length; } public boolean hasNext() { while (this.entry == null || (this.entryCanonical = this.entry.get()) == null) { if (this.entry != null) { // Skip past a cleared Reference. this.entry = this.entry.next; } else { if (this.index <= 0) { return false; } else { this.entry = this.table[--this.index]; } } } return true; } public T next() { if (!hasNext()) { throw new NoSuchElementException(); } this.entry = this.entry.next; return this.entryCanonical; } public void remove() { throw new UnsupportedOperationException(); } } }