What is the difference between the keyword volatile and atomic data types in the context of multithreading?

The volatile keyword in the context of multithreading guarantees that reading and writing a variable will occur directly from memory, not from the CPU cache, ensuring visibility of changes between threads. However, it does not guarantee atomicity of operations — for example, incrementing a volatile variable is not atomic.

Atomic data types (such as AtomicInteger in Java) provide not only visibility of changes between threads but also atomicity of operations — operations on such types are performed as indivisible, preventing race conditions.

Example in Java:

volatile int counter = 0;
// Increment is not atomic:
counter++;

AtomicInteger atomicCounter = new AtomicInteger(0);
// Atomic increment:
atomicCounter.incrementAndGet();

Thus, volatile only provides visibility, while atomic types provide both visibility and atomicity of operations.