WeakHashtable (open_kit Maven Webapp 1.1.12 API)

java.lang.Object
- java.util.Dictionary<K,V>
- - java.util.Hashtable
  - - org.apache.commons.logging.impl.WeakHashtable

所有已实现的接口:

java.io.Serializable, java.lang.Cloneable, java.util.Map
```
public final class WeakHashtable
extends java.util.Hashtable
```
Implementation of Hashtable that uses 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 symantics 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 enviroments running 1.3+ JVMs. Use of this class in most cases (see below) will allow classloaders 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 implementationd 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 java.lang.ref.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 classloaders; when the component loads a LogFactory instance via the component classloader a reference to it gets stored in the static LogFactory.factories member, keyed by the component's classloader so different components don't stomp on each other. When the component is later unloaded, the container sets the component's classloader to null with the intent that all the component's classes get garbage-collected. However there's still a reference to the component's classloader from a key in the "global" LogFactory's factories member! If LogFactory.release() is called whenever component is unloaded, the classloaders will be correctly garbage collected; this should be done by any container that bundles commons-logging by default. However, holding the classloader references weakly ensures that the classloader 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 classloader but a subclass of LogFactory [LogFactory1] is loaded by the component's classloader 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 classloader via getClass().getClassLoader(). This chain of references will prevent collection of the child classloader.

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

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

从以下版本开始:

1.1

作者:

Brian Stansberry

另请参阅:

序列化表格

构造器概要

构造器
构造器和说明

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

构造器
构造器和说明
`WeakHashtable()` Constructs a WeakHashtable with the Hashtable default capacity and load factor.

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`boolean`	`containsKey(java.lang.Object key)`
`java.util.Enumeration`	`elements()`
`java.util.Set`	`entrySet()`
`java.lang.Object`	`get(java.lang.Object key)`
`boolean`	`isEmpty()`
`java.util.Enumeration`	`keys()`
`java.util.Set`	`keySet()`
`java.lang.Object`	`put(java.lang.Object key, java.lang.Object value)`
`void`	`putAll(java.util.Map t)`
`protected void`	`rehash()`
`java.lang.Object`	`remove(java.lang.Object key)`
`int`	`size()`
`java.lang.String`	`toString()`
`java.util.Collection`	`values()`

从类继承的方法 java.util.Hashtable
clear, clone, compute, computeIfAbsent, computeIfPresent, contains, containsValue, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll

从类继承的方法 java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- 构造器详细资料
  - WeakHashtable
```
public WeakHashtable()
```
    Constructs a WeakHashtable with the Hashtable default capacity and load factor.
- 方法详细资料
  - containsKey
```
public boolean containsKey(java.lang.Object key)
```
    指定者:
    
    containsKey 在接口中 java.util.Map
    
    覆盖:
    
    containsKey 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - elements
```
public java.util.Enumeration elements()
```
    覆盖:
    
    elements 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - entrySet
```
public java.util.Set entrySet()
```
    指定者:
    
    entrySet 在接口中 java.util.Map
    
    覆盖:
    
    entrySet 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - get
```
public java.lang.Object get(java.lang.Object key)
```
    指定者:
    
    get 在接口中 java.util.Map
    
    覆盖:
    
    get 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - keys
```
public java.util.Enumeration keys()
```
    覆盖:
    
    keys 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - keySet
```
public java.util.Set keySet()
```
    指定者:
    
    keySet 在接口中 java.util.Map
    
    覆盖:
    
    keySet 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - put
```
public java.lang.Object put(java.lang.Object key,
                            java.lang.Object value)
```
    指定者:
    
    put 在接口中 java.util.Map
    
    覆盖:
    
    put 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - putAll
```
public void putAll(java.util.Map t)
```
    指定者:
    
    putAll 在接口中 java.util.Map
    
    覆盖:
    
    putAll 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - values
```
public java.util.Collection values()
```
    指定者:
    
    values 在接口中 java.util.Map
    
    覆盖:
    
    values 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - remove
```
public java.lang.Object remove(java.lang.Object key)
```
    指定者:
    
    remove 在接口中 java.util.Map
    
    覆盖:
    
    remove 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - isEmpty
```
public boolean isEmpty()
```
    指定者:
    
    isEmpty 在接口中 java.util.Map
    
    覆盖:
    
    isEmpty 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - size
```
public int size()
```
    指定者:
    
    size 在接口中 java.util.Map
    
    覆盖:
    
    size 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - toString
```
public java.lang.String toString()
```
    覆盖:
    
    toString 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable
  - rehash
```
protected void rehash()
```
    覆盖:
    
    rehash 在类中 java.util.Hashtable
    
    另请参阅:
    
    Hashtable

类 WeakHashtable

构造器概要

方法概要

从类继承的方法 java.util.Hashtable

从类继承的方法 java.lang.Object

构造器详细资料

WeakHashtable

方法详细资料

containsKey

elements

entrySet

get

keys

keySet

put

putAll

values

remove

isEmpty

size

toString

rehash