atomic

Korinsky’s Atomic

It is the low-latency atomic operations for a multi-threads environment for JVM.

It has similar API with java.util.concurrent.atomic but it much faster at the multi-threads environment, you can just update imports and enjoy it.

Each time when CAS loop can’t update the value, it disables current thread for a very smaller possible time to prevent stupid looping when another thread may release the value.

How to use it?

It is in Maven Central, and can be added to a Maven project as follows

        <dependency>
            <groupId>ky.korins</groupId>
            <artifactId>atomic</artifactId>
            <version>1.1</version>
        </dependency>

How fast is it?

It is similar with j.u.c.atomic for one concurrent thread and has 2x times lower latency for bigger concurrency.

Full benchmark:

Measured at Intel(R) Xeon(R) CPU E5-1650 v3 @ 3.50GHz at

openjdk version "9.0.1"
OpenJDK Runtime Environment (build 9.0.1+11-Debian-1)
OpenJDK 64-Bit Server VM (build 9.0.1+11-Debian-1, mixed mode)

Which operations does it support?

Right now it supports AtomicLong, AtomicInteger, AtomicBoolean, AtomicLongArray and AtomicIntegerArray with Java8 compatibility API.

Why does j.u.c.atomic increment is faster without concurrent threads?

This atomic implemented all operation includes getAndAdd* and addAndGet* over CAS-loop, j.u.c.atomic’s getAndAdd and addAndGet* uses lock addq CPU instruction or just i++ where i is volatile variable that much faster without concurrent threads.

Why does it add unspecified backoff timeout?

JVM hasn’t got a way to make very small specified sleep period. It has few different ways to add a sleep period:

• Thread.onSpinWait() since Java9
• Thread.yield()
• Thread.sleep(long millis) or Thread.sleep(long millis, int nanos)
• Object.wait(long timeout, int nanos) or Object.wait(long timeout, int nanos)
• LockSupport.parkNanos(long nanos)
• TimeUnit.sleep(x)

If we check the code we will see that:

• Object.wait(0, 1) is Object.wait(1)
• Thread.sleep(0, 1) is Thread.sleep(0) or Thread.sleep(1) that depends on amount of nanos
• TimeUnit.sleep(X) is Thread.sleep(ms, ns)

And if we made a simple test we will have results:

on my laptop with macOS I have

Benchmark                     Mode  Cnt        Score      Error  Units
LockSupport.parkNanos(1)      avgt   20    10553.701 ±  309.104  ns/op
LockSupport.parkNanos(10)     avgt   20    13006.281 ±   73.393  ns/op
LockSupport.parkNanos(100)    avgt   20    12976.135 ±  139.048  ns/op
LockSupport.parkNanos(1000)   avgt   20     5795.405 ±  132.921  ns/op
LockSupport.parkNanos(10000)  avgt   20     6127.251 ±  203.732  ns/op
Object.wait(0, 1)             avgt   20  1351918.387 ± 7285.491  ns/op
Thread.onSpinWait()           avgt   20        3.271 ±    0.047  ns/op
Thread.sleep(0)               avgt   20      258.652 ±    3.411  ns/op
Thread.yield()                avgt   20      225.066 ±    3.808  ns/op

on debian sid I have

Benchmark                     Mode  Cnt        Score      Error  Units
LockSupport.parkNanos(1)      avgt   20      288.112 ±    1.606  ns/op
LockSupport.parkNanos(10)     avgt   20      285.572 ±    0.784  ns/op
LockSupport.parkNanos(100)    avgt   20     4674.412 ±  237.567  ns/op
LockSupport.parkNanos(1000)   avgt   20    55064.592 ±  245.676  ns/op
LockSupport.parkNanos(10000)  avgt   20    54860.746 ±  593.290  ns/op
Object.wait(0, 1)             avgt   20  1120201.743 ± 2152.094  ns/op
Thread.onSpinWait()           avgt   20        2.496 ±    0.003  ns/op
Thread.sleep(0)               avgt   20      183.340 ±    2.365  ns/op
Thread.yield()                avgt   20      170.595 ±    2.303  ns/op

JVM hasn’t got any way to make a small specified timeout and:

• Object.wait(0, 1) is about 1 ms
• LockSupport.parkNanos(long nanos) is absolutely unpredictable
• Thread.sleep(0) and Thread.yield() very close (~13%) but depends on platform
• Thread.onSpinWait() is faster but depends on platform and works only since Java9

Thread.onSpinWait() is converted to pause CPU instruction if the target system supports it (by CPU and by JVM), and to nothing, when it doesn’t..

Honestly, we don’t need just pause, the idea of this low-latency atomic operation is doesn’t burn CPU cycles for CAS-loop when another threads may finish same CAS-loop.

Anyway, this code is using LockSupport.parkNanos(1) because tests’ve shown that it is the best option.

Very short summary (only p0.9999):

Full data: