Improve emulation of the java.util.concurrent package

[zbynek]

Though these methods cannot provide true concurrency, they can still be implemented to improve interoperability.

java.util.concurrent.ConcurrentHashMap#forEach(long, BiConsumer)\
java.util.concurrent.ConcurrentHashMap#forEach(long, BiFunction, Consumer)\
java.util.concurrent.ConcurrentHashMap#keySet(Object)\
java.util.concurrent.ConcurrentHashMap#mappingCount()\
java.util.concurrent.ConcurrentHashMap#newKeySet(int)\
java.util.concurrent.ConcurrentHashMap#search(long, BiFunction)\
java.util.concurrent.ConcurrentHashMap#reduce(long, BiFunction, BiFunction)\
java.util.concurrent.ConcurrentHashMap#reduceToDouble(long, ToDoubleBiFunction, double, DoubleBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#reduceToLong(long, ToLongBiFunction, long, LongBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#reduceToInt(long, ToIntBiFunction, int, IntBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#forEachKey(long, Consumer)\
java.util.concurrent.ConcurrentHashMap#forEachKey(long, Function, Consumer)\
java.util.concurrent.ConcurrentHashMap#searchKeys(long, Function)\
java.util.concurrent.ConcurrentHashMap#reduceKeys(long, BiFunction)\
java.util.concurrent.ConcurrentHashMap#reduceKeys(long, Function, BiFunction)\
java.util.concurrent.ConcurrentHashMap#reduceKeysToDouble(long, ToDoubleFunction, double, DoubleBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#reduceKeysToLong(long, ToLongFunction, long, LongBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#reduceKeysToInt(long, ToIntFunction, int, IntBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#forEachValue(long, Function, Consumer)\
java.util.concurrent.ConcurrentHashMap#forEachValue(long, Consumer)\
java.util.concurrent.ConcurrentHashMap#searchValues(long, Function)\
java.util.concurrent.ConcurrentHashMap#reduceValues(long, BiFunction)\
java.util.concurrent.ConcurrentHashMap#reduceValues(long, Function, BiFunction)\
java.util.concurrent.ConcurrentHashMap#reduceValuesToDouble(long, ToDoubleFunction, double, DoubleBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#reduceValuesToLong(long, ToLongFunction, long, LongBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#reduceValuesToInt(long, ToIntFunction, int, IntBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#forEachEntry(long, Consumer)\
java.util.concurrent.ConcurrentHashMap#forEachEntry(long, Function, Consumer)\
java.util.concurrent.ConcurrentHashMap#searchEntries(long, Function)\
java.util.concurrent.ConcurrentHashMap#reduceEntries(long, BiFunction)\
java.util.concurrent.ConcurrentHashMap#reduceEntries(long, Function, BiFunction)\
java.util.concurrent.ConcurrentHashMap#reduceEntriesToDouble(long, ToDoubleFunction, double, DoubleBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#reduceEntriesToLong(long, ToLongFunction, long, LongBinaryOperator)\
java.util.concurrent.ConcurrentHashMap#reduceEntriesToInt(long, ToIntFunction, int, IntBinaryOperator)\
java.util.concurrent.Executors#newWorkStealingPool()\
java.util.concurrent.Executors#newWorkStealingPool(int)\
java.util.concurrent.Executors#unconfigurableExecutorService(ExecutorService)\
java.util.concurrent.Executors#unconfigurableScheduledExecutorService(ScheduledExecutorService)\
java.util.concurrent.Executors#privilegedCallable(Callable)\
java.util.concurrent.Executors#privilegedCallableUsingCurrentClassLoader(Callable)\
java.util.concurrent.Executors#callable(PrivilegedAction)\
java.util.concurrent.Executors#callable(PrivilegedExceptionAction)\
java.util.concurrent.atomic.AtomicBoolean#getOpaque()\
java.util.concurrent.atomic.AtomicBoolean#setOpaque(boolean)\
java.util.concurrent.atomic.AtomicBoolean#getAcquire()\
java.util.concurrent.atomic.AtomicBoolean#setRelease(boolean)\
java.util.concurrent.atomic.AtomicBoolean#compareAndExchange(boolean, boolean)\
java.util.concurrent.atomic.AtomicBoolean#compareAndExchangeAcquire(boolean, boolean)\
java.util.concurrent.atomic.AtomicBoolean#compareAndExchangeRelease(boolean, boolean)\
java.util.concurrent.atomic.AtomicBoolean#weakCompareAndSetPlain(boolean, boolean)\
java.util.concurrent.atomic.AtomicBoolean#weakCompareAndSetAcquire(boolean, boolean)\
java.util.concurrent.atomic.AtomicBoolean#weakCompareAndSetRelease(boolean, boolean)\
java.util.concurrent.atomic.AtomicBoolean#weakCompareAndSetVolatile(boolean, boolean)\
java.util.concurrent.atomic.AtomicBoolean#getPlain()\
java.util.concurrent.atomic.AtomicBoolean#setPlain(boolean)\
java.util.concurrent.atomic.AtomicInteger#getOpaque()\
java.util.concurrent.atomic.AtomicInteger#setOpaque(int)\
java.util.concurrent.atomic.AtomicInteger#getAcquire()\
java.util.concurrent.atomic.AtomicInteger#setRelease(int)\
java.util.concurrent.atomic.AtomicInteger#compareAndExchange(int, int)\
java.util.concurrent.atomic.AtomicInteger#compareAndExchangeAcquire(int, int)\
java.util.concurrent.atomic.AtomicInteger#compareAndExchangeRelease(int, int)\
java.util.concurrent.atomic.AtomicInteger#weakCompareAndSetPlain(int, int)\
java.util.concurrent.atomic.AtomicInteger#weakCompareAndSet(int, int)\
java.util.concurrent.atomic.AtomicInteger#weakCompareAndSetAcquire(int, int)\
java.util.concurrent.atomic.AtomicInteger#weakCompareAndSetRelease(int, int)\
java.util.concurrent.atomic.AtomicInteger#weakCompareAndSetVolatile(int, int)\
java.util.concurrent.atomic.AtomicInteger#getAndUpdate(IntUnaryOperator)\
java.util.concurrent.atomic.AtomicInteger#updateAndGet(IntUnaryOperator)\
java.util.concurrent.atomic.AtomicInteger#getAndAccumulate(int, IntBinaryOperator)\
java.util.concurrent.atomic.AtomicInteger#accumulateAndGet(int, IntBinaryOperator)\
java.util.concurrent.atomic.AtomicInteger#getPlain()\
java.util.concurrent.atomic.AtomicInteger#setPlain(int)\
java.util.concurrent.atomic.AtomicLong#getOpaque()\
java.util.concurrent.atomic.AtomicLong#setOpaque(long)\
java.util.concurrent.atomic.AtomicLong#getAcquire()\
java.util.concurrent.atomic.AtomicLong#setRelease(long)\
java.util.concurrent.atomic.AtomicLong#compareAndExchange(long, long)\
java.util.concurrent.atomic.AtomicLong#compareAndExchangeAcquire(long, long)\
java.util.concurrent.atomic.AtomicLong#compareAndExchangeRelease(long, long)\
java.util.concurrent.atomic.AtomicLong#weakCompareAndSetPlain(long, long)\
java.util.concurrent.atomic.AtomicLong#weakCompareAndSet(long, long)\
java.util.concurrent.atomic.AtomicLong#weakCompareAndSetAcquire(long, long)\
java.util.concurrent.atomic.AtomicLong#weakCompareAndSetRelease(long, long)\
java.util.concurrent.atomic.AtomicLong#weakCompareAndSetVolatile(long, long)\
java.util.concurrent.atomic.AtomicLong#getAndUpdate(LongUnaryOperator)\
java.util.concurrent.atomic.AtomicLong#updateAndGet(LongUnaryOperator)\
java.util.concurrent.atomic.AtomicLong#getAndAccumulate(long, LongBinaryOperator)\
java.util.concurrent.atomic.AtomicLong#accumulateAndGet(long, LongBinaryOperator)\
java.util.concurrent.atomic.AtomicLong#getPlain()\
java.util.concurrent.atomic.AtomicLong#setPlain(long)\
java.util.concurrent.atomic.AtomicReference#getOpaque()\
java.util.concurrent.atomic.AtomicReference#setOpaque(Object)\
java.util.concurrent.atomic.AtomicReference#getAcquire()\
java.util.concurrent.atomic.AtomicReference#setRelease(Object)\
java.util.concurrent.atomic.AtomicReference#compareAndExchange(Object, Object)\
java.util.concurrent.atomic.AtomicReference#compareAndExchangeAcquire(Object, Object)\
java.util.concurrent.atomic.AtomicReference#compareAndExchangeRelease(Object, Object)\
java.util.concurrent.atomic.AtomicReference#weakCompareAndSetPlain(Object, Object)\
java.util.concurrent.atomic.AtomicReference#weakCompareAndSetAcquire(Object, Object)\
java.util.concurrent.atomic.AtomicReference#weakCompareAndSetRelease(Object, Object)\
java.util.concurrent.atomic.AtomicReference#weakCompareAndSetVolatile(Object, Object)\
java.util.concurrent.atomic.AtomicReference#getAndUpdate(UnaryOperator)\
java.util.concurrent.atomic.AtomicReference#updateAndGet(UnaryOperator)\
java.util.concurrent.atomic.AtomicReference#getAndAccumulate(Object, BinaryOperator)\
java.util.concurrent.atomic.AtomicReference#accumulateAndGet(Object, BinaryOperator)\
java.util.concurrent.atomic.AtomicReference#getPlain()\
java.util.concurrent.atomic.AtomicReference#setPlain(Object)\
java.util.concurrent.atomic.AtomicReferenceArray#getOpaque(int)\
java.util.concurrent.atomic.AtomicReferenceArray#setOpaque(int, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#getAcquire(int)\
java.util.concurrent.atomic.AtomicReferenceArray#setRelease(int, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#compareAndExchange(int, Object, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#compareAndExchangeAcquire(int, Object, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#compareAndExchangeRelease(int, Object, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#weakCompareAndSetPlain(int, Object, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#weakCompareAndSetAcquire(int, Object, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#weakCompareAndSetRelease(int, Object, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#weakCompareAndSetVolatile(int, Object, Object)\
java.util.concurrent.atomic.AtomicReferenceArray#getAndUpdate(int, UnaryOperator)\
java.util.concurrent.atomic.AtomicReferenceArray#updateAndGet(int, UnaryOperator)\
java.util.concurrent.atomic.AtomicReferenceArray#getAndAccumulate(int, Object, BinaryOperator)\
java.util.concurrent.atomic.AtomicReferenceArray#accumulateAndGet(int, Object, BinaryOperator)\
java.util.concurrent.atomic.AtomicReferenceArray#getPlain(int)\
java.util.concurrent.atomic.AtomicReferenceArray#setPlain(int, Object)\
java.util.stream.Collectors#groupingByConcurrent(Function, Collector)\
java.util.stream.Collectors#groupingByConcurrent(Function, Supplier, Collector)\
java.util.stream.Collectors#groupingByConcurrent(Function)\
java.util.stream.Collectors#toConcurrentMap(Function, Function)\
java.util.stream.Collectors#toConcurrentMap(Function, Function, BinaryOperator, Supplier)\
java.util.stream.Collectors#toConcurrentMap(Function, Function, BinaryOperator)