private static final int hash(final Object key) {
    int h = key.hashCode();     // The real hashCode call
    h ^= (h>>>20) ^ (h>>>12);
    h ^= (h>>> 7) ^ (h>>> 4);
	h += h<<7; // smear low bits up high, for hashcodes that only differ by 1
    return h;
  }
A lock-free alternate implementation of {@link java.util.concurrent.ConcurrentHashMap}
with better scaling properties and generally lower costs to mutate the Map.
It provides identical correctness properties as ConcurrentHashMap.  All
operations are non-blocking and multi-thread safe, including all update
operations.  {@link NonBlockingHashMap} scales substantially better than
{@link java.util.concurrent.ConcurrentHashMap} for high update rates, even with a
large concurrency factor.  Scaling is linear up to 768 CPUs on a 768-CPU
Azul box, even with 100% updates or 100% reads or any fraction in-between.
Linear scaling up to all cpus has been observed on a 32-way Sun US2 box,
32-way Sun Niagara box, 8-way Intel box and a 4-way Power box.

This class obeys the same functional specification as {@link
java.util.Hashtable}, and includes versions of methods corresponding to
each method of <tt>Hashtable</tt>. However, even though all operations are
thread-safe, operations do <em>not</em> entail locking and there is
<em>not</em> any support for locking the entire table in a way that
prevents all access.  This class is fully interoperable with
<tt>Hashtable</tt> in programs that rely on its thread safety but not on
its synchronization details.

<p> Operations (including <tt>put</tt>) generally do not block, so may
overlap with other update operations (including other <tt>puts</tt> and
<tt>removes</tt>).  Retrievals reflect the results of the most recently
<em>completed</em> update operations holding upon their onset.  For
aggregate operations such as <tt>putAll</tt>, concurrent retrievals may
reflect insertion or removal of only some entries.  Similarly, Iterators
and Enumerations return elements reflecting the state of the hash table at
some point at or since the creation of the iterator/enumeration.  They do
<em>not</em> throw {@link ConcurrentModificationException}.  However,
iterators are designed to be used by only one thread at a time.

<p> Very full tables, or tables with high re-probe rates may trigger an
internal resize operation to move into a larger table.  Resizing is not
terribly expensive, but it is not free either; during resize operations
table throughput may drop somewhat.  All threads that visit the table
during a resize will 'help' the resizing but will still be allowed to
complete their operation before the resize is finished (i.e., a simple
'get' operation on a million-entry table undergoing resizing will not need
to block until the entire million entries are copied).

<p>This class and its views and iterators implement all of the
<em>optional</em> methods of the {@link Map} and {@link Iterator}
interfaces.

<p> Like {@link Hashtable} but unlike {@link HashMap}, this class
does <em>not</em> allow <tt>null</tt> to be used as a key or value.


@since 1.5
@author Cliff Click
@param <TypeK> the type of keys maintained by this map
@param <TypeV> the type of mapped values
jctools-core/src/main/java/org/jctools/maps/NonBlockingHashMap.java