See: Description
| Interface | Description |
|---|---|
| Associated<T> |
The Associated interface facilitates the creation of a very generic
equivalence relation between different objects and allows to group them
based on the equality of the "association key" object returned by the
Associated.getAssociatedKey() method. |
| Associator |
The Associator interface facilitates the creation of a very generic
equivalence relation between different objects and allows to group them
based on the equality of the "association key" object returned by the
Associator.getAssociatedKey(java.lang.Object) method. |
| CanonicallyNamed |
CanonicallyNamed provides a way for objects to identify themselves by name.
|
| Cloneable |
This interface is meant to "fix" the usability issues related to the
Cloneable method-less interface. |
| Cloner |
A Cloner provides an external means for producing copies of objects as
prescribed by the
Object.clone() contract. |
| Collector<V> |
A Collector is mechanism for receiving items.
|
| Continuation<R> |
Continuation interface is used to implement asynchronous post-processing,
the pattern that is also known as the
"Continuation-passing style".
|
| Converter<F,T> |
Provide for "pluggable" object conversions.
|
| Disposable |
The Disposable interface is used for life-cycle management of resources.
|
| Factory<T> |
The Factory interface provides a means of producing objects of a given
type.
|
| Hasher<V> |
A Hasher provides an external means for producing hash codes and comparing
objects for equality.
|
| Holder<V> |
A Holder is a reference like object, i.e. it simply holds another object.
|
| Lockable |
The Lockable interface is used for managing exclusive access to thread-safe
classes.
|
| Lockable.Unlockable |
The Unlockable interface is used for releasing the exclusive access to
this Lockable.
|
| Notifier |
A Condition-like object, used to block thread(s) for a notification.
|
| Pollable<E> |
The Pollable interface describes a component which supports element removal.
|
| Predicate<T> |
Predicate represents a boolean test of an object.
|
| Class | Description |
|---|---|
| Blocking |
Blocking provides a set of helper methods related to blocking a thread.
|
| ConcurrentNotifier |
A Condition-like object, usable by multiple threads to both wait and signal.
|
| ConcurrentNotifier.Link |
A link in a stack of waiting threads.
|
| IdentityHasher<V> |
IdentityHasher provides a Hasher implementation based upon an object's
identity hashCode and reference
equality. |
| IdentityHolder<V> |
A Holder implementation which additionally provides an equals/hashCode implementation based on the held
object's identity.
|
| InverseComparator<T> |
InverseComparator is a wrapper comparator which simply inverses the comparison result.
|
| MutableLong |
A Long like class which supports mutation.
|
| NaturalAssociator |
NaturalAssociator provides an Associator implementation for objects that
implement the
Associated interface. |
| NaturalCloner |
A Cloner that clones
Cloneable objects. |
| NaturalComparator<T extends Comparable<T>> |
NaturalComparator is a comparator which simply delegates to a Comparable object's compare implementation.
|
| NaturalHasher<V> | |
| NonBlocking |
NonBlocking allows a thread to mark itself as non-blocking and should be exempt from things such as
flow-control pauses using a try-with-resource pattern.
|
| SimpleHolder<V> |
SimpleHolder is a basic implementation of the Holder interface.
|
| SingleWaiterCooperativeNotifier |
SingleWaiterCooperativeNotifier is an extension of the SingleWaiterMultiNotifier which attempts to offload
potentially expensive "notification" work from signaling threads onto the waiting threads.
|
| SingleWaiterMultiNotifier |
A Condition-like object, used by a single thread to block for a
notification, and optimized for many concurrent notifications by other
threads.
|
| Timeout |
Timeout provides a mechanism for allowing a thread to interrupt itself if it doesn't return
to a specific call site within a given timeout.
|
| VolatileHolder<V> |
VolatileHolder is a basic implementation of the Holder interface where
the held object is referenced from a volatile reference.
|