Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Reducing Java Streams Server Load With AirConcurrentMap

DZone's Guide to

Reducing Java Streams Server Load With AirConcurrentMap

Servers that are under continuous load, rather than single-threaded apps with batch operations, react in a completely different way to parallelism.

· Java Zone ·
Free Resource

Download Microservices for Java Developers: A hands-on introduction to frameworks and containers. Brought to you in partnership with Red Hat.

The Java 8 streams feature is an excellent way to perform semi-declarative operations on Maps, especially as it provides improved performance via almost free parallelism, taking advantage of the increasing core count of modern computers. However, the parallelism is primarily useful in single-threaded applications which have batch operations to do on Maps. Servers that are under continuous load react in a completely different way to parallelism, and we will show here graphically what happens.

We will discuss:

  • The most basic stream operations and how to use them, as applied to a max() function. This function is very fast on Long-valued Maps, so the differences between Map implementations is most apparent.

  • The effects of heavy server load on stream performance, with graphical results.

  • The Java Microbenchmarking Harness JMH, with the example code which generated the results.

  • The streaming performance of AirConcurrentMap, a standard ConcurrentNavigableMap written by the author.

Basic Stream Use

It is easy to use a stream to calculate, for example, the maximum of a Long-valued Map, which will be our test case. We can do it several ways. As an example, we can use a reduce():

    Map<Object, Long> map = new HashMap<Object, Long>();
    // fill the map...

    return map.values().stream()
                     .reduce(Long.MIN_VALUE, (x, y) -> x > y ? x : y);


In order to maximize performance, we can convert the stream to a LongStream

    return map.values().stream()
                    .mapToLong(o -> ((Long)o).longValue())
                    .reduce(Long.MIN_VALUE, (x, y) -> x > y ? x : y);


Then, in order to get the parallelism for free, we just chain in a .parallel() invocation:

    return map.values().stream().parallel()
                    .mapToLong(o -> ((Long)o).longValue())
                    .reduce(Long.MIN_VALUE, (x, y) -> x > y ? x : y);


It turns out the LongStream has a built-in max() method, but it returns an OptionalLong, which is a bit more trouble so we ignore it. It just does a reduce(Math::max) anyway.

Test Setup

We used the excellent Java Microbenchmarking Harness to do fair and precise testing. This framework handles almost all of the hard work in testing, including process forking, setup, threading, looping, timing, parameterization, and statistics including confidence intervals. It is good for small pieces of code that are to execute frequently as well as slower operations. We present the entire test code below. Our test code also has a selection of other interesting Map performance measurements. The scanning techniques we cover are very important, because they can easily become the chief bottleneck, and not all situations cause get(), put(), and remove()to be limiting, particularly in large Maps.

We will cover various techniques for finding the maximum of a Map with Long values, including iterating, Map.forEach(), serial streams, and parallel streams, for both 8- and 100-thread loads. The system is an Intel X86-64 2.4GHz quad core. So, with 8 threads we are fully loading the CPU, but many servers have very large numbers of threads handling web hits.

We Use Only ConcurrentMaps

In this testing, we assume that the Maps may be modified during the scanning. This will normally be the case in a server environment, because most Maps cannot simply be loaded with data when the server boots and then held static thereafter. Various tricks can be used to avoid problems with write/write and read/write access overlap, but in general, if a system contains multiple threads, non-concurrent Maps can be very dangerous. Write/read overlaps may occasionally return wrong results and write/write failures may even permanently corrupt the structure of the Map. These failures manifest rarely and may be difficult to understand, detect and diagnose. So, we do not use bare HashMapand TreeMap, but wrap them using Collections.synchronizedMap(Map). Catching ConcurrentModificationExceptionis not a reliable means to detect wrong results or corruption and it is not guaranteed to be thrown at all, in spite of the choice of a particular Map implementation to have the ‘fail-fast’ characteristic.

Problems With Collections.synchronizedMap()

It is easy to adapt HashMapand TreeMap— or any other Map — for Thread safety using Collections.synchronizedMap(Map). This static method simply wraps the given Map and returns a new instance of a private SynchronizedMap which delegates almost every method within a synchronized() block. However, the resulting Map is not very satisfactory. The model is incomplete, slow, and risky:

  • The wrapped Map may no longer be used directly, so all references to it must be hidden safely.

  • Iterators, Map.forEach(BiConsumer), Spliterators, and streams uses are not synchronized (possibly others too?). These must be synchronized explicitly at the point of use. The synchronization must be on the SynchronizedMap itself, and not on the wrapped Map. Outside code such as library code that receives a SynchronizedMap may fail to do such scan synchronization.

  • All access is serialized, so only one core is used.

  • Scans may dramatically delay otherwise fast operations such as get(), put() and remove() in other Threads, reducing throughput in those Threads: ConcurrentMapsavoid this problem.

  • If a Map is wrapped more than once in different places, access may still overlap and cause problems. It is not enough to do a temporary wrapping at each point of use.

  • Synchronization is slow compared to some Map operations, especially when wait queues build up. Synchronization is very fast, however, when there is no contention.

Nevertheless, we test HashMapand TreeMap in their synchronized forms.

The Tested Maps

We test over:

  • AirConcurrentMap – a java.util.concurrent.ConcurrentNavigableMap from boilerbay.com.

  • Synchronized java.util.HashMap.

  • Sychronized java.util.TreeMap.

  • java.util.concurrent.ConcurrentHashMap.

  • java.util.concurrent.ConcurrentSkipListMap.

General Conclusions

These are rough observations – you should look at the graphs for yourself. Generally, the four scanning techniques have widely different startup times, efficiency, and inter-thread interference. The variations over different Map implementations are extreme as well.

  • Iteration is slower than Map.forEach( BiConsumer), sometimes very much.

  • Iteration and forEach() start fast, peak at about 100 entries, then slow down.

  • Streams have a significant startup delay.

  • The synchronized HashMap and TreeMapare very slow.

  • The 8-Thread case is comparable to the 100-Thread case.

  • For small Maps, ConcurrentSkipListMap is best, for large Maps, AirConcurrentMap is best, with a break-even point from 100 to 10K Entries.

  • Parallel streams are slow, and actually slower than serial streams in these high-load cases, except for AirConcurrentMap, which remains fast. This is because AirConcurrentMap 3.2 uses only serial scan even for parallel streams. Parallel scanning as discussed in a previous DZone article will be added transparently later.

The Graphs

The 8-thread Graphs:

Image title

Image title

Image title


Image title


The 100-thread Graphs:

Image title


Image title

Image title


The Java Microbenchmarking Harness Code

The JMH code is very concise, owing to the fact that only a few Annotated features are needed, factoring out almost everything but the state, setup methods, and benchmark methods. We have parameterized the tests so that JMH will sweep over a range of Map sizes and Map implementations. The testing uses the Maven framework so it is easy to setup and use. The code here provides many interesting performance metrics. The command line can override the Annotated setup defaults. Each benchmark method must return a value so that there is some tangible result that prevents the JIT from removing all the code!

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;

@Fork(1)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@BenchmarkMode(Mode.Throughput)
// @OutputTimeUnit(TimeUnit.SECONDS)
@Threads(8)
@State(Scope.Benchmark)
public class ServerLoadJMHMapTest {

    @Param({ "0", "1", "10", "100", "1000", "10000", "100000", "1000000", "10000000" })
    static long mapSize;

    @Param({
            "com.infinitydb.map.air.AirConcurrentMap",
            "java.util.HashMap",
            "java.util.TreeMap",
            "java.util.concurrent.ConcurrentHashMap",
            "java.util.concurrent.ConcurrentSkipListMap"
    })
    static String mapClassName;
    static Map<Long, Long> map;
    // This will be optimized out by the JIT
    static boolean isCollectionsSynchronizedMap;

    @Setup(Level.Trial)
    static public void setup() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Class<Map<Long, Long>> mapClass =
                (Class<Map<Long, Long>>)Class.forName(mapClassName);
        map = mapClass.newInstance();
        if (!(map instanceof ConcurrentMap)) {
            isCollectionsSynchronizedMap = true;
            if (!(map instanceof NavigableMap))
                map = Collections.synchronizedMap(map);
            else
                map = Collections.synchronizedNavigableMap((NavigableMap)map);
        }
        // Random random = new Random(System.nanoTime());
        Random random = new Random(1);
        // Load up the Map
        for (long i = 0; i < mapSize; i++) {
            long o = random.nextLong();
            map.put(o, o);
        }
    }

    @Benchmark
    public static long testServerLoadGet() {
        long k = ThreadLocalRandom.current().nextLong();
        Long v = map.get(k);
        return v == null ? Integer.MIN_VALUE : v;
    }

    /*
     * We have to do both put() and remove() so the map doesn't change size and
     * so the remove() actually has an effect because the removed key actually

     * exists.
     */
    @Benchmark
    public static long testServerLoadPutRemove() {
        long k = ThreadLocalRandom.current().nextLong();;
        map.put(k, k);
        return map.remove(k);
    }

    @Benchmark
    public static long testServerLoadIterator() {
        long max = Long.MIN_VALUE;
        // This if condition is actually very fast and the JIT will remove it.
        if (isCollectionsSynchronizedMap) {
            // Must synch on the map, not the iterator or values!
            // This prevents concurrent modification
            synchronized (map) {

                for (Long v : map.values()) {
                    max = v > max ? v : max;
                }
            }
        } else {
            for (Long v : map.values()) {
                max = v > max ? v : max;
            }
        }
        return max;
    }

    @Benchmark
    public static long testServerLoadForEach() {
       class SummingBiConsumer implements BiConsumer<Object, Long> {
            long max = Long.MIN_VALUE;
            public void accept(Object k, Long v) {
                max = v > max ? v : max;
            }
        }
        SummingBiConsumer summingBiConsumer = new SummingBiConsumer();
        if (isCollectionsSynchronizedMap) {
            // Must synch on the map, not the iterator or values!
            // This prevents concurrent modification
            synchronized (map) {
                map.forEach(summingBiConsumer);
            }
        } else {
            map.forEach(summingBiConsumer);
        }
        return summingBiConsumer.max;
    }

    @Benchmark
    public static long testServerLoadSerialStream() {
        // This if condition is actually very fast and the JIT will remove it.
        if (isCollectionsSynchronizedMap) {
            // Must synch on the map, not the iterator or values!
            // This prevents concurrent modification
            synchronized (map) {

                return map.values().stream()
                        .mapToLong(o -> ((Long)o).longValue())
                        .reduce(Long.MIN_VALUE, (x, y) -> x > y ? x : y);
            }
        } else {
            return map.values().stream()
                    .mapToLong(o -> ((Long)o).longValue())
                    .reduce(Long.MIN_VALUE, (x, y) -> x > y ? x : y);
        }
    }

    @Benchmark
    public static long testServerLoadParallelStream() {
        // This if condition is actually very fast and the JIT will remove it.
        if (isCollectionsSynchronizedMap) {
            // Must synch on the map, not the iterator or set!
            // This prevents concurrent modification
            synchronized (map) {
                return map.values().stream().parallel()
                        .mapToLong(o -> ((Long)o).longValue())
                        .reduce(Long.MIN_VALUE, (x, y) -> x > y ? x : y);
            }
        } else {
            return map.values().stream().parallel()
                    .mapToLong(o -> ((Long)o).longValue())
                    .reduce(Long.MIN_VALUE, (x, y) -> x > y ? x : y);
        }
    }
}


Result Data

Here is the result data obtained by running this command with an X86-64 ORACLE Java 8 JVM:

java -Xmx4g -jar target/benchmarks.jar

Note that the graphical representations show performance in terms of values per second, which is the product of ops/s and mapsize. As a bonus, the performance of get() is included, plus that of put() combined with remove().

# Run complete. Total time: 00:53:49





Benchmark                                                                      (mapClassName)  (mapSize)   Mode  Cnt           Score   Error  Units

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap          0  thrpt    2    23047433.238          ops/s

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap          1  thrpt    2    20491184.297          ops/s

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap         10  thrpt    2    11020398.731          ops/s

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap        100  thrpt    2     4558195.217          ops/s

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap       1000  thrpt    2     1712967.071          ops/s

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap      10000  thrpt    2      171565.943          ops/s

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap     100000  thrpt    2       18723.255          ops/s

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap    1000000  thrpt    2         739.927          ops/s

ServerLoadJMHMapTest.testServerLoadForEach            com.infinitydb.map.air.AirConcurrentMap   10000000  thrpt    2          53.046          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap          0  thrpt    2    17036848.467          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap          1  thrpt    2    14748081.919          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap         10  thrpt    2    10329174.206          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap        100  thrpt    2     2700102.001          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap       1000  thrpt    2      317592.584          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap      10000  thrpt    2        7593.322          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap     100000  thrpt    2        1750.220          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap    1000000  thrpt    2         125.705          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.HashMap   10000000  thrpt    2          11.524          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap          0  thrpt    2    18178273.043          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap          1  thrpt    2    18544975.851          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap         10  thrpt    2     9115543.859          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap        100  thrpt    2     1829794.525          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap       1000  thrpt    2      142824.981          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap      10000  thrpt    2        8600.766          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap     100000  thrpt    2         381.963          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap    1000000  thrpt    2          46.626          ops/s

ServerLoadJMHMapTest.testServerLoadForEach                                  java.util.TreeMap   10000000  thrpt    2           6.144          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap          0  thrpt    2  1178182652.402          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap          1  thrpt    2   152602535.950          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap         10  thrpt    2    79011494.041          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap        100  thrpt    2     6656813.612          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap       1000  thrpt    2      723730.510          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap      10000  thrpt    2       34412.013          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap     100000  thrpt    2         934.148          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap    1000000  thrpt    2          84.053          ops/s

ServerLoadJMHMapTest.testServerLoadForEach             java.util.concurrent.ConcurrentHashMap   10000000  thrpt    2           8.387          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap          0  thrpt    2  1075001021.052          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap          1  thrpt    2   634515157.695          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap         10  thrpt    2   164781749.555          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap        100  thrpt    2    20618465.193          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap       1000  thrpt    2     1401510.997          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap      10000  thrpt    2       51707.682          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap     100000  thrpt    2        1213.355          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap    1000000  thrpt    2         121.542          ops/s

ServerLoadJMHMapTest.testServerLoadForEach         java.util.concurrent.ConcurrentSkipListMap   10000000  thrpt    2           8.082          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap          0  thrpt    2     5789752.082          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap          1  thrpt    2     7916730.951          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap         10  thrpt    2     5945631.282          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap        100  thrpt    2     4517997.389          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap       1000  thrpt    2     3604161.595          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap      10000  thrpt    2     4310142.861          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap     100000  thrpt    2     4678352.906          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap    1000000  thrpt    2     5297491.406          ops/s

ServerLoadJMHMapTest.testServerLoadGet                com.infinitydb.map.air.AirConcurrentMap   10000000  thrpt    2     2875975.481          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap          0  thrpt    2     8112338.901          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap          1  thrpt    2     8407822.931          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap         10  thrpt    2     7650281.880          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap        100  thrpt    2     8194484.303          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap       1000  thrpt    2     7314026.839          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap      10000  thrpt    2     7758733.115          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap     100000  thrpt    2     6264293.372          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap    1000000  thrpt    2     3694720.332          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.HashMap   10000000  thrpt    2      616921.335          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap          0  thrpt    2     8904266.711          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap          1  thrpt    2     8714794.742          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap         10  thrpt    2     8147617.952          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap        100  thrpt    2     6222054.495          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap       1000  thrpt    2     3594163.202          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap      10000  thrpt    2     3013752.755          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap     100000  thrpt    2     1618463.932          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap    1000000  thrpt    2      838131.382          ops/s

ServerLoadJMHMapTest.testServerLoadGet                                      java.util.TreeMap   10000000  thrpt    2      609922.560          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap          0  thrpt    2     3111304.489          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap          1  thrpt    2     3102437.302          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap         10  thrpt    2     3094475.655          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap        100  thrpt    2     3100185.812          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap       1000  thrpt    2     3189228.398          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap      10000  thrpt    2     3169807.105          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap     100000  thrpt    2     3097192.146          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap    1000000  thrpt    2     3100381.782          ops/s

ServerLoadJMHMapTest.testServerLoadGet                 java.util.concurrent.ConcurrentHashMap   10000000  thrpt    2     1898969.068          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap          0  thrpt    2     3457006.498          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap          1  thrpt    2     3133892.724          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap         10  thrpt    2     3117124.456          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap        100  thrpt    2     3340889.066          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap       1000  thrpt    2     3417555.903          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap      10000  thrpt    2     4016906.843          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap     100000  thrpt    2     5530252.120          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap    1000000  thrpt    2     3796383.168          ops/s

ServerLoadJMHMapTest.testServerLoadGet             java.util.concurrent.ConcurrentSkipListMap   10000000  thrpt    2     1263945.390          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap          0  thrpt    2    28014823.979          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap          1  thrpt    2    24048597.060          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap         10  thrpt    2    11126146.184          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap        100  thrpt    2     4435674.947          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap       1000  thrpt    2      103464.889          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap      10000  thrpt    2       50524.608          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap     100000  thrpt    2        4736.649          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap    1000000  thrpt    2         301.904          ops/s

ServerLoadJMHMapTest.testServerLoadIterator           com.infinitydb.map.air.AirConcurrentMap   10000000  thrpt    2          14.594          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap          0  thrpt    2     6270544.346          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap          1  thrpt    2     6406216.460          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap         10  thrpt    2     6044084.811          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap        100  thrpt    2     2026376.771          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap       1000  thrpt    2      199345.652          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap      10000  thrpt    2        9647.064          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap     100000  thrpt    2        1362.145          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap    1000000  thrpt    2         155.430          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.HashMap   10000000  thrpt    2          17.683          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap          0  thrpt    2     6225070.005          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap          1  thrpt    2     5917760.935          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap         10  thrpt    2     5838389.725          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap        100  thrpt    2     1728546.641          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap       1000  thrpt    2      142588.839          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap      10000  thrpt    2        4730.083          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap     100000  thrpt    2         878.238          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap    1000000  thrpt    2          67.434          ops/s

ServerLoadJMHMapTest.testServerLoadIterator                                 java.util.TreeMap   10000000  thrpt    2           6.502          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap          0  thrpt    2   860000338.409          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap          1  thrpt    2   154597815.396          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap         10  thrpt    2    81745604.372          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap        100  thrpt    2     7093417.135          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap       1000  thrpt    2      668463.955          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap      10000  thrpt    2       30176.666          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap     100000  thrpt    2         928.106          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap    1000000  thrpt    2          74.003          ops/s

ServerLoadJMHMapTest.testServerLoadIterator            java.util.concurrent.ConcurrentHashMap   10000000  thrpt    2           8.559          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap          0  thrpt    2   684741984.183          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap          1  thrpt    2   506261119.993          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap         10  thrpt    2   147373264.854          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap        100  thrpt    2    18999835.182          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap       1000  thrpt    2     1527160.431          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap      10000  thrpt    2       53445.149          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap     100000  thrpt    2        1427.061          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap    1000000  thrpt    2         147.546          ops/s

ServerLoadJMHMapTest.testServerLoadIterator        java.util.concurrent.ConcurrentSkipListMap   10000000  thrpt    2           8.782          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap          0  thrpt    2     6777906.317          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap          1  thrpt    2     6653033.426          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap         10  thrpt    2     5274794.953          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap        100  thrpt    2     3300112.876          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap       1000  thrpt    2     1722115.468          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap      10000  thrpt    2      171773.428          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap     100000  thrpt    2       19295.182          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap    1000000  thrpt    2         723.960          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream     com.infinitydb.map.air.AirConcurrentMap   10000000  thrpt    2          47.434          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap          0  thrpt    2     4158483.876          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap          1  thrpt    2     3714731.001          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap         10  thrpt    2      171207.735          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap        100  thrpt    2       84009.851          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap       1000  thrpt    2       66503.603          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap      10000  thrpt    2       18284.734          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap     100000  thrpt    2         694.486          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap    1000000  thrpt    2          62.325          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.HashMap   10000000  thrpt    2           8.474          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap          0  thrpt    2     3981301.448          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap          1  thrpt    2     3988870.306          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap         10  thrpt    2      155345.974          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap        100  thrpt    2       97388.076          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap       1000  thrpt    2       63098.729          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap      10000  thrpt    2       20633.695          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap     100000  thrpt    2        1642.898          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap    1000000  thrpt    2          67.075          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream                           java.util.TreeMap   10000000  thrpt    2           8.622          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap          0  thrpt    2    23130698.292          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap          1  thrpt    2    22213585.616          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap         10  thrpt    2     2055151.185          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap        100  thrpt    2      646402.804          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap       1000  thrpt    2      268935.434          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap      10000  thrpt    2       28443.726          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap     100000  thrpt    2        1670.126          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap    1000000  thrpt    2          57.028          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream      java.util.concurrent.ConcurrentHashMap   10000000  thrpt    2           7.111          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap          0  thrpt    2    27538202.864          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap          1  thrpt    2    27337394.527          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap         10  thrpt    2     4350052.833          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap        100  thrpt    2      690071.500          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap       1000  thrpt    2      117743.840          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap      10000  thrpt    2       24077.926          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap     100000  thrpt    2        3257.692          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap    1000000  thrpt    2         178.520          ops/s

ServerLoadJMHMapTest.testServerLoadParallelStream  java.util.concurrent.ConcurrentSkipListMap   10000000  thrpt    2           7.285          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap          0  thrpt    2     2645942.975          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap          1  thrpt    2     2655891.644          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap         10  thrpt    2     2610152.221          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap        100  thrpt    2     2584800.401          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap       1000  thrpt    2     2543944.483          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap      10000  thrpt    2      974393.128          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap     100000  thrpt    2     2651240.002          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap    1000000  thrpt    2     4002925.744          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove          com.infinitydb.map.air.AirConcurrentMap   10000000  thrpt    2     1445806.741          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap          0  thrpt    2     3482365.861          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap          1  thrpt    2     3703935.246          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap         10  thrpt    2     3727039.603          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap        100  thrpt    2     3558929.641          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap       1000  thrpt    2     3246673.701          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap      10000  thrpt    2     3220283.326          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap     100000  thrpt    2     3132581.289          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap    1000000  thrpt    2     2456302.191          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.HashMap   10000000  thrpt    2     1335042.831          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap          0  thrpt    2     3028583.757          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap          1  thrpt    2     3707695.065          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap         10  thrpt    2     3460363.938          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap        100  thrpt    2     2838226.314          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap       1000  thrpt    2     3001686.525          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap      10000  thrpt    2     2473986.854          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap     100000  thrpt    2     2199882.581          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap    1000000  thrpt    2     1183774.194          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove                                java.util.TreeMap   10000000  thrpt    2      293745.620          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap          0  thrpt    2     3496060.019          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap          1  thrpt    2     3552443.412          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap         10  thrpt    2     3601286.144          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap        100  thrpt    2     3523514.309          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap       1000  thrpt    2     3448373.725          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap      10000  thrpt    2     3484472.261          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap     100000  thrpt    2     3433852.622          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap    1000000  thrpt    2     3602261.470          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove           java.util.concurrent.ConcurrentHashMap   10000000  thrpt    2      945151.433          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap          0  thrpt    2     2873985.824          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap          1  thrpt    2     3055640.162          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap         10  thrpt    2     2932301.437          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap        100  thrpt    2     4911826.805          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap       1000  thrpt    2     5117860.885          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap      10000  thrpt    2     5146802.901          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap     100000  thrpt    2     5835795.891          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap    1000000  thrpt    2     3208159.162          ops/s

ServerLoadJMHMapTest.testServerLoadPutRemove       java.util.concurrent.ConcurrentSkipListMap   10000000  thrpt    2      413309.235          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap          0  thrpt    2    10335910.649          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap          1  thrpt    2     9328192.407          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap         10  thrpt    2     4868566.851          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap        100  thrpt    2     3658623.399          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap       1000  thrpt    2     1642789.440          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap      10000  thrpt    2      174199.022          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap     100000  thrpt    2       18281.599          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap    1000000  thrpt    2         827.833          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream       com.infinitydb.map.air.AirConcurrentMap   10000000  thrpt    2          52.652          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap          0  thrpt    2     5145836.764          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap          1  thrpt    2     4224648.552          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap         10  thrpt    2     3875736.974          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap        100  thrpt    2      992210.569          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap       1000  thrpt    2       80769.068          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap      10000  thrpt    2        7358.194          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap     100000  thrpt    2         462.946          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap    1000000  thrpt    2          97.642          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.HashMap   10000000  thrpt    2          13.733          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap          0  thrpt    2     5603446.680          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap          1  thrpt    2     4708457.280          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap         10  thrpt    2     4154241.202          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap        100  thrpt    2     1383738.489          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap       1000  thrpt    2      150193.167          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap      10000  thrpt    2        8537.591          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap     100000  thrpt    2         557.913          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap    1000000  thrpt    2         104.055          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream                             java.util.TreeMap   10000000  thrpt    2           9.081          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap          0  thrpt    2    34912231.548          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap          1  thrpt    2    34844548.692          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap         10  thrpt    2    30093686.483          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap        100  thrpt    2     3602677.843          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap       1000  thrpt    2      470995.908          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap      10000  thrpt    2       28279.414          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap     100000  thrpt    2         908.598          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap    1000000  thrpt    2          71.442          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream        java.util.concurrent.ConcurrentHashMap   10000000  thrpt    2           7.822          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap          0  thrpt    2    39319374.682          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap          1  thrpt    2    34374487.204          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap         10  thrpt    2    33398466.884          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap        100  thrpt    2     5898985.205          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap       1000  thrpt    2     1185387.269          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap      10000  thrpt    2      100570.817          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap     100000  thrpt    2        1420.870          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap    1000000  thrpt    2         125.789          ops/s

ServerLoadJMHMapTest.testServerLoadSerialStream    java.util.concurrent.ConcurrentSkipListMap   10000000  thrpt    2           9.130          ops/s


Summary

Under heavy thread load, parallel Map streams behave differently than in the few-threaded case. Parallelism only works well when cores are actually available for use that would otherwise be idle. The overhead of the parallelism framework can become very great.

Collections.synchronizedMap() is slow, inconvenient and risky. AirConcurrentMap is best above about 100 to 10K Entries, while ConcurrentSkipListMap is best below that.

Download Building Reactive Microservices in Java: Asynchronous and Event-Based Application Design. Brought to you in partnership with Red Hat

Topics:
java ,concurrency ,streams ,parallelism ,server

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}