Package com.cedarsoftware.util

Class ClassValueMap<V>

java.lang.Object
java.util.AbstractMap<Class<?>,V>
com.cedarsoftware.util.ClassValueMap<V>
Type Parameters:
V - the type of mapped values
All Implemented Interfaces:
ConcurrentMap<Class<?>,V>, Map<Class<?>,V>
public class ClassValueMap<V> extends AbstractMap<Class<?>,V> implements ConcurrentMap<Class<?>,V>
A Map implementation keyed on Class objects that leverages a ClassValue cache for extremely fast lookups. This specialized collection is designed for scenarios where you frequently need to retrieve values associated with Class keys.

Performance Advantages

ClassValueMap provides significantly faster get() operations compared to standard Map implementations:

  • 2-10x faster than HashMap for key lookups
  • 3-15x faster than ConcurrentHashMap for concurrent access patterns
  • The performance advantage increases with contention (multiple threads)
  • Most significant when looking up the same class keys repeatedly

How It Works

The implementation utilizes Java's ClassValue mechanism, which is specially optimized in the JVM through:

  • Thread-local caching for reduced contention
  • Identity-based lookups (faster than equality checks)
  • Special VM support that connects directly to Class metadata structures
  • Optimized memory layout that can reduce cache misses

Drop-in Replacement

ClassValueMap is designed as a drop-in replacement for existing maps with Class keys:

  • Fully implements the Map and ConcurrentMap interfaces
  • Supports all standard map operations (put, remove, clear, etc.)
  • Handles null keys and null values just like standard map implementations
  • Thread-safe for all operations

Ideal Use Cases

ClassValueMap is ideal for:

  • High read-to-write ratio scenarios (read-mostly workloads)
  • Caches for class-specific handlers, factories, or metadata
  • Performance-critical operations in hot code paths
  • Type registries in frameworks (serializers, converters, validators)
  • Class capability or feature mappings
  • Any system that frequently maps from Class objects to associated data

Trade-offs

The performance benefits come with some trade-offs:

  • Higher memory usage (maintains both a backing map and ClassValue cache)
  • Write operations (put/remove) aren't faster and may be slightly slower
  • Only Class keys benefit from the optimized lookups

Thread Safety

This implementation is thread-safe for all operations and implements ConcurrentMap.

Usage Example


 // Create a registry of class handlers
 ClassValueMap<Handler> handlerRegistry = new ClassValueMap<>();
 handlerRegistry.put(String.class, new StringHandler());
 handlerRegistry.put(Integer.class, new IntegerHandler());
 handlerRegistry.put(List.class, new ListHandler());

 // Fast lookup in a performance-critical context
 public void process(Object obj) {
     Handler handler = handlerRegistry.get(obj.getClass());
     if (handler != null) {
         handler.handle(obj);
     } else {
         // Default handling
     }
 }

Important Performance Warning

Wrapping this class with standard collection wrappers like Collections.unmodifiableMap() or Collections.newSetFromMap() will destroy the ClassValue performance benefits. Always use the raw ClassValueMap directly or use the provided unmodifiableView() method if immutability is required.

Author:
John DeRegnaucourt ([email protected])
Copyright (c) Cedar Software LLC

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

License

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.
See Also: