WeakHashtable (Apache Commons Logging 1.4.0 API)
Description: declaration: package: org.apache.commons.logging.impl, class: WeakHashtable

Package org.apache.commons.logging.impl

# Class WeakHashtable

java.lang.Object
java.util.Dictionary
java.util.Hashtable
org.apache.commons.logging.impl.WeakHashtable

All Implemented Interfaces:
  `Serializable`, `Cloneable`, `Map`

@Deprecated public final class WeakHashtable extends Hashtable
Deprecated.
No longer used, will be removed in 2.0.
Implements `Hashtable` to use `WeakReference`'s to hold its keys thus allowing them to be reclaimed by the garbage collector. The associated values are retained using strong references.

This class follows the semantics of `Hashtable` as closely as possible. It therefore does not accept null values or keys.

Note: This is not intended to be a general purpose hash table replacement. This implementation is also tuned towards a particular purpose: for use as a replacement for `Hashtable` in `LogFactory`. This application requires good liveliness for `get` and `put`. Various tradeoffs have been made with this in mind.

Usage: typical use case is as a drop-in replacement for the `Hashtable` used in `LogFactory` for J2EE environments running 1.3+ JVMs. Use of this class in most cases (see below) will allow class loaders to be collected by the garbage collector without the need to call `LogFactory.release(ClassLoader)`.

`org.apache.commons.logging.LogFactory` checks whether this class can be supported by the current JVM, and if so then uses it to store references to the `LogFactory` implementation it loads (rather than using a standard Hashtable instance). Having this class used instead of `Hashtable` solves certain issues related to dynamic reloading of applications in J2EE-style environments. However this class requires Java 1.3 or later (due to its use of `WeakReference` and associates). And by the way, this extends `Hashtable` rather than `HashMap` for backwards compatibility reasons. See the documentation for method `LogFactory.createFactoryStore` for more details.

The reason all this is necessary is due to a issue which arises during hot deploy in a J2EE-like containers. Each component running in the container owns one or more class loaders; when the component loads a LogFactory instance via the component class loader a reference to it gets stored in the static LogFactory.factories member, keyed by the component's class loader so different components don't stomp on each other. When the component is later unloaded, the container sets the component's class loader to null with the intent that all the component's classes get garbage-collected. However there's still a reference to the component's class loader from a key in the "global" `LogFactory`'s factories member! If `LogFactory.release()` is called whenever component is unloaded, the class loaders will be correctly garbage collected; this should be done by any container that bundles commons-logging by default. However, holding the class loader references weakly ensures that the class loader will be garbage collected without the container performing this step.

Limitations: There is still one (unusual) scenario in which a component will not be correctly unloaded without an explicit release. Though weak references are used for its keys, it is necessary to use strong references for its values.

If the abstract class `LogFactory` is loaded by the container class loader but a subclass of `LogFactory` [LogFactory1] is loaded by the component's class loader and an instance stored in the static map associated with the base LogFactory class, then there is a strong reference from the LogFactory class to the LogFactory1 instance (as normal) and a strong reference from the LogFactory1 instance to the component class loader via `getClass().getClassLoader()`. This chain of references will prevent collection of the child class loader.

Such a situation occurs when the commons-logging.jar is loaded by a parent class loader (e.g. a server level class loader in a servlet container) and a custom `LogFactory` implementation is loaded by a child class loader (e.g. a web app class loader).

To avoid this scenario, ensure that any custom LogFactory subclass is loaded by the same class loader as the base `LogFactory`. Creating custom LogFactory subclasses is, however, rare. The standard LogFactoryImpl class should be sufficient for most or all users.

Since:
  1.1
See Also:
  - Serialized Form

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `WeakHashtable()`
  Deprecated.
  Constructs a WeakHashtable with the Hashtable default capacity and load factor.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `boolean`
  `containsKey(Object key)`
  Deprecated.
  `Enumeration`
  `elements()`
  Deprecated.
  `Set`
  `entrySet()`
  Deprecated.
  `Object`
  `get(Object key)`
  Deprecated.
  `boolean`
  `isEmpty()`
  Deprecated.
  `Enumeration`
  `keys()`
  Deprecated.
  `Set`
  `keySet()`
  Deprecated.
  `Object`
  `put(Object key, Object value)`
  Deprecated.
  `void`
  `putAll(Map t)`
  Deprecated.
  `protected void`
  `rehash()`
  Deprecated.
  `Object`
  `remove(Object key)`
  Deprecated.
  `int`
  `size()`
  Deprecated.
  `String`
  `toString()`
  Deprecated.
  `Collection`
  `values()`
  Deprecated.

  ### Methods inherited from class java.util.Hashtable

  `clear, clone, compute, computeIfAbsent, computeIfPresent, contains, containsValue, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll`

  ### Methods inherited from class java.lang.Object

  `finalize, getClass, notify, notifyAll, wait, wait, wait`

- ## Constructor Details

  - ### WeakHashtable

    public WeakHashtable()
    Deprecated.
    Constructs a WeakHashtable with the Hashtable default capacity and load factor.

- ## Method Details

  - ### containsKey

    public boolean containsKey(Object key)
    Deprecated.
    Specified by:
      `containsKey` in interface `Map`
    Overrides:
      `containsKey` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### elements

    public Enumeration elements()
    Deprecated.
    Overrides:
      `elements` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### entrySet

    public Set entrySet()
    Deprecated.
    Specified by:
      `entrySet` in interface `Map`
    Overrides:
      `entrySet` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### get

    public Object get(Object key)
    Deprecated.
    Specified by:
      `get` in interface `Map`
    Overrides:
      `get` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### isEmpty

    public boolean isEmpty()
    Deprecated.
    Specified by:
      `isEmpty` in interface `Map`
    Overrides:
      `isEmpty` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### keys

    public Enumeration keys()
    Deprecated.
    Overrides:
      `keys` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### keySet

    public Set keySet()
    Deprecated.
    Specified by:
      `keySet` in interface `Map`
    Overrides:
      `keySet` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### put

    public Object put(Object key, Object value)
    Deprecated.
    Specified by:
      `put` in interface `Map`
    Overrides:
      `put` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### putAll

    public void putAll(Map t)
    Deprecated.
    Specified by:
      `putAll` in interface `Map`
    Overrides:
      `putAll` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### rehash

    protected void rehash()
    Deprecated.
    Overrides:
      `rehash` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### remove

    public Object remove(Object key)
    Deprecated.
    Specified by:
      `remove` in interface `Map`
    Overrides:
      `remove` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### size

    public int size()
    Deprecated.
    Specified by:
      `size` in interface `Map`
    Overrides:
      `size` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### toString

    public String toString()
    Deprecated.
    Overrides:
      `toString` in class `Hashtable`
    See Also:
      - `Hashtable`

  - ### values

    public Collection values()
    Deprecated.
    Specified by:
      `values` in interface `Map`
    Overrides:
      `values` in class `Hashtable`
    See Also:
      - `Hashtable`