Is volatile int faster than AtomicInteger

Question

I am doing currently a sample exercise and i found one weird observation that if I replace AutomicInteger with volatile program runs faster. Note : I am only doing read operations. code: ``` import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; public class Main { AtomicInteger integer = new AtomicInteger(100000000); // volatile int integer= 100000000; public static void main(String[] args) { // We will store the threads so that we can check if they are done List threads = new ArrayList(); long start = System.currentTimeMillis(); Main main = new Main(); // We will create 500 threads for (int i = 0; i < 500; i++) { Runnable task = new MyRunnable(main.integer); Thread worker = new Thread(task); // We can set the name of the thread worker.setName(String.valueOf(i)); // Start the thread, never call method run() direct worker.start(); // Remember the thread for later usage threads.add(worker); } int running = 0; do { running =…

Accepted Answer

`AtomicInteger` in read context is basically a thin wrapper around `volatile int`:

```
private volatile int value;

public final int get() {
    return value;
}

public int intValue() {
    return get();
}
```

Don't expect the wrapper to be faster then the wrapped value taken alone. It can only be as fast as the `volatile int` if inlining is employed by the JVM.

And hint: if you are "only doing read operations", this will be even faster:

```
static final int integer= 100000000;
```

Is volatile int faster than AtomicInteger

Solution

Problem