Fast, Efficient AirConcurrentMap

AirConcurrentMap is a high speed Java in-memory data storage component for key/value entries called a Map.  It has these features:

  • Faster streaming than JDK Maps at medium to large scale (version 3.2 and later).
  • Reduces Streaming Server Load in busy cases at medium to large scale (version 3.2 and later)
  • 90% Faster searching than Java ConcurrentSkipListMap (for get/put/remove and higher/lower/floor/ceiling)
  • 30% to 50% More Capacity than any standard Java Map above 1K Entries
  • Iterators are several times faster than those in any standard Java Map, increasing with scale
  • MapVisitors capability is much faster than standard Java Map Iterators, increasing with scale. It is similar to forEach()
  • ThreadedMapVisitors  capability is much faster than Java 8 serial or parallel streams at all scales
  • Low garbage generation, unlike most other Maps
  • Returns all freed space, unlike Hash-based Maps, down to one block
  • Compatible with all standards

We give free advance customer support by a software engineer for our products. Contact us and see at

AirConcurrentMap is free for non-commercial use without source, or commercially licensed with or without source.

Add it to your application, change the constructor and test it or try the trivial tests we tweeted or our extensive performance tests.  For specific details see AirConcurrentMap Space Efficiency, high speed Iterators, Visitors and ThreadedVisitors, and Java Map AirConcurrentMap versus ConcurrentSkipListMap Speed. For an extensive performance analysis see AirConcurrentMap_Performance_Testing.pdf. You can run the tests provided for the standard Java Microbenchmarking Harness yourself, to compare performance with all other Java library Maps.

The standard Map Interface Tree

The standard Java Map version 1.6 libraries have this interface structure, with the blue boxes being the standard interfaces of the Java Collections Framework, and the green being the implementations provided in the standard Java Map library. The most basic interface is Map, at the top. but the most complete functionality is at the bottom, in Java ConcurrentNavigableMap. On the left side going down, the Java Map subinterfaces add ordering, which is slower but far more capable and flexible. On the right going down, concurrency is added, which allows for thread safety and multi-core concurrency for overlapped execution. AirConcurrentMap, being a ConcurrentNavigableMap, is both ordered and multi-core.


The capabilities of the various Java Maps can be seen in this bullet chart. AirConcurrentMap is ordered and concurrent, hence is a universal drop-in replacement for any other Java Map. This means the capacity increase above 1K Entries, iteration speedup and multi-core concurrency is always available simply by replacing the constructors in the code.


The graphs below show how easily AirConcurrentMap beats ConcurrentSkipListMap. The curves show not only higher speed, but also end with more entries, showing AirConcurrentMap time and space advantages. The curves end where the JVM slows down and runs out of space at 2GB with 64-bit Java 1.8 client in a quad-core 2.3GHz Intel i7 with 8GBRAM on Windows 7. These and many other detailed graphs are provided in AirConcurrentMap Performance Testing.

Get Tests


Put Tests


Iteration Speed

Note the scan speed of the AirConcurrentMap can be further much improved  by using the special  MapVisitors and ThreadedMapVisitors techniques. This is with 32-bit Java 7 on a 2.4 Ghz X86-64.


Iterator Speed Logarithmic Size

Here the X-axis is the logarithm of the Map size. The advantage grows very large starting at about 50K Entries. This is with 64-bit Java 8 on a 2.4 Ghz X86-64 quad core, single-threaded. Note that the advantage rapidly reaches reaches about two times as size increases.

ForEach() Logarithmic Size

Beyond about 100 Entries, AirConcurrentMap is faster, reaching about twice the speed of any other JDK Map. The special AirConcurrentMap MapVisitor technique is almost identical in usage to forEach(), but somewhat faster. Use the ThreadedMapVisitor parallel scan for much more performance.