Java Tutorial/Collections/WeakHashMap

Create a WeakHashMap with a single element in it

import java.util.Map;
import java.util.WeakHashMap;
public class Main {
  public static void main(String args[]) {
    final Map<String, String> map = new WeakHashMap<String, String>();
    map.put(new String("A"), "B");
    Runnable runner = new Runnable() {
      public void run() {
        while (map.containsKey("A")) {
          try {
            Thread.sleep(500);
          } catch (InterruptedException ignored) {
          }
          System.gc();
        }
      }
    };
    Thread t = new Thread(runner);
    t.start();
    try {
      t.join();
    } catch (InterruptedException ignored) {
    }
  }
}

Demonstrating the WeakHashMap

import java.util.Map;
import java.util.WeakHashMap;
public class MainClass {
  private static Map map;
  public static void main(String args[]) {
    map = new WeakHashMap();
    map.put("A", "B");
    Runnable runner = new Runnable() {
      public void run() {
        while (map.containsKey("A")) {
          try {
            Thread.sleep(1000);
            System.gc();
          } catch (InterruptedException ignored) {
          }
          System.out.println("Has A");
          System.gc();
        }
      }
    };
    Thread t = new Thread(runner);
    t.start();
    System.out.println("Main waiting");
    try {
      t.join();
    } catch (InterruptedException ignored) {
    }
    System.gc();
  }
}

Implements a combination of WeakHashMap and IdentityHashMap

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * Implements a combination of WeakHashMap and IdentityHashMap.
 * Useful for caches that need to key off of a == comparison
 * instead of a .equals.
 * 
 * <b>
 * This class is not a general-purpose Map implementation! While
 * this class implements the Map interface, it intentionally violates
 * Map"s general contract, which mandates the use of the equals method
 * when comparing objects. This class is designed for use only in the
 * rare cases wherein reference-equality semantics are required.
 * 
 * Note that this implementation is not synchronized.
 * </b>
 */
public class WeakIdentityHashMap<K, V> implements Map<K, V> {
    private final ReferenceQueue<K> queue = new ReferenceQueue<K>();
    private Map<IdentityWeakReference, V> backingStore = new HashMap<IdentityWeakReference, V>();

    public WeakIdentityHashMap() {
    }

    public void clear() {
        backingStore.clear();
        reap();
    }
    public boolean containsKey(Object key) {
        reap();
        return backingStore.containsKey(new IdentityWeakReference(key));
    }
    public boolean containsValue(Object value)  {
        reap();
        return backingStore.containsValue(value);
    }
    public Set<Map.Entry<K, V>> entrySet() {
        reap();
        Set<Map.Entry<K, V>> ret = new HashSet<Map.Entry<K, V>>();
        for (Map.Entry<IdentityWeakReference, V> ref : backingStore.entrySet()) {
            final K key = ref.getKey().get();
            final V value = ref.getValue();
            Map.Entry<K, V> entry = new Map.Entry<K, V>() {
                public K getKey() {
                    return key;
                }
                public V getValue() {
                    return value;
                }
                public V setValue(V value) {
                    throw new UnsupportedOperationException();
                }
            };
            ret.add(entry);
        }
        return Collections.unmodifiableSet(ret);
    }
    public Set<K> keySet() {
        reap();
        Set<K> ret = new HashSet<K>();
        for (IdentityWeakReference ref : backingStore.keySet()) {
            ret.add(ref.get());
        }
        return Collections.unmodifiableSet(ret);
    }
    public boolean equals(Object o) {
        return backingStore.equals(((WeakIdentityHashMap)o).backingStore);
    }
    public V get(Object key) {
        reap();
        return backingStore.get(new IdentityWeakReference(key));
    }
    public V put(K key, V value) {
        reap();
        return backingStore.put(new IdentityWeakReference(key), value);
    }
    public int hashCode() {
        reap();
        return backingStore.hashCode();
    }
    public boolean isEmpty() {
        reap();
        return backingStore.isEmpty();
    }
    public void putAll(Map t) {
        throw new UnsupportedOperationException();
    }
    public V remove(Object key) {
        reap();
        return backingStore.remove(new IdentityWeakReference(key));
    }
    public int size() {
        reap();
        return backingStore.size();
    }
    public Collection<V> values() {
        reap();
        return backingStore.values();
    }
    private synchronized void reap() {
        Object zombie = queue.poll();
        while (zombie != null) {
            IdentityWeakReference victim = (IdentityWeakReference)zombie;
            backingStore.remove(victim);
            zombie = queue.poll();
        }
    }
    class IdentityWeakReference extends WeakReference<K> {
        int hash;
        
        @SuppressWarnings("unchecked")
        IdentityWeakReference(Object obj) {
            super((K)obj, queue);
            hash = System.identityHashCode(obj);
        }
        public int hashCode() {
            return hash;
        }
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            IdentityWeakReference ref = (IdentityWeakReference)o;
            if (this.get() == ref.get()) {
                return true;
            }
            return false;
        }
    }
}

To enable automatically release of the value, the value must be wrapped in a WeakReference object

import java.lang.ref.WeakReference;
import java.util.Iterator;
import java.util.Map;
import java.util.WeakHashMap;
public class Main {
  public static void main(String[] argv) throws Exception {
    Object keyObject = "";
    Object valueObject = "";
    Map weakMap = new WeakHashMap();
    weakMap.put(keyObject, valueObject);
    WeakReference weakValue = new WeakReference(valueObject);
    weakMap.put(keyObject, weakValue);
    Iterator it = weakMap.keySet().iterator();
    while (it.hasNext()) {
      Object key = it.next();
      weakValue = (WeakReference) weakMap.get(key);
      if (weakValue == null) {
        System.out.println("Value has been garbage-collected");
      } else {
        System.out.println("Get value");
        valueObject = weakValue.get();
      }
    }
  }
}

Understanding Weak References

1. Reference class is defined in the java.lang.ref package.
2. Instead of providing variables that directly reference your memory, you create a reference object that indirectly holds a reference to the object.
3. The reference objects are then maintained in a reference queue (ReferenceQueue), which monitors the references for reachability by the garbage collector.

There are four types of references to objects.

1. Direct references like you normally use, as in Integer i = new Integer(13), are called strong references and have no special class. The remaining three are soft references (SoftReference), weak references (WeakReference), and phantom references (PhantomReference).
2. Soft references are like a cache. When memory is low, the garbage collector can arbitrarily free up soft references if there are no strong references to the object. If you are using soft references, the garbage collector is required to free them all before throwing an OutOfMemoryException.
3. Weak references are weaker than soft references. If the only references to an object are weak references, the garbage collector can reclaim the object"s memory at any time-it doesn"t have to wait until the system runs out of memory. Usually, it will be freed the next time the garbage collector runs.
4. Phantom references are special. They allow you to be notified before the garbage collector performs finalization and frees the object. Think of it as a mechanism to perform cleanup.

(Referend from Ivor Horton"s Beginning Java 2, JDK 5 Edition by Ivor Horton Wrox Press 2005)

WeakHashMap Class

If the Java memory manager no longer has a strong reference to the object specified as a key, then the entry in the map will be removed.

Creating a WeakHashMap: The four constructors of WeakHashMap are the same as HashMap

public WeakHashMap()
public WeakHashMap(int initialCapacity)
public WeakHashMap(int initialCapacity, float loadFactor)
public WeakHashMap(Map map)