Volatile Keyword

The volatile keyword in Java is used in multithreaded programming to ensure visibility of shared variables across threads.

It guarantees that when one thread updates a variable, all other threads immediately see the updated value.

What is volatile in Java?

In Java, each thread may keep a local cached copy of variables (CPU cache / thread working memory) for performance reasons.

Because of this, a change made by one thread may not be visible to other threads immediately.

👉 The volatile keyword solves this visibility problem.

Definition :

A variable declared as volatile is always read from and written to main memory, not from a thread’s local cache.

volatilebooleanrunning=true;

Why is volatile Needed?

Without volatile:

• Threads may work with stale (outdated) values
• Updates made by one thread may never be seen by others
• Can cause infinite loops, inconsistent reads, or unexpected behavior

Example Problem (Without volatile)

classSharedFlag {
booleanrunning=true;
}

• One thread sets running = false
• Another thread may never see the change
• The loop may run forever

How volatile Works (Internals)

The volatile keyword provides the following guarantees:

1. Visibility Guarantee

• Every write to a volatile variable is immediately flushed to main memory
• Every read gets the latest value from main memory
• No stale data is read by threads

2. Happens-Before Relationship

• A write to a volatile variable happens-before every subsequent read
• Ensures correct ordering of operations across threads

3. No Instruction Reordering

• JVM and CPU are restricted from reordering reads/writes of volatile variables
• Prevents subtle concurrency bugs

What volatile Does NOT Do

Very important limitations:

• Does NOT provide mutual exclusion
• Does NOT lock threads
• Does NOT make compound operations atomic
• Does NOT replace synchronized or locks

Incorrect Usage Example

volatileintcount=0;

count++;// NOT thread-safe

count++ is a read–modify–write operation and can still cause race conditions.

Correct Usage Example

classVolatileExample {
privatevolatilebooleanrunning=true;

publicvoidstop() {
        running =false;
    }

publicvoidrun() {
while (running) {
// do work
        }
        System.out.println("Stopped safely");
    }
}

• When one thread calls stop()
• All other threads immediately see running = false

Volatile vs Synchronized

Volatile vs Atomic Classes

Correct Alternative for Counters

import java.util.concurrent.atomic.AtomicInteger;

class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // atomic operation
    }

    public int getCount() {
        return count.get();
    }
}

When to Use volatile

Use volatile when:

• Variable is read by many threads
• Written by only one thread
• Operations are simple read/write
• You need fast visibility without locking

Common Use Cases

• Stop / shutdown flags
• Configuration reload flags
• Status indicators
• Feature toggles

Do NOT use volatile when:

• You need atomic operations
• Multiple variables must be updated together
• You are modifying shared state inside a critical section

👉 Use synchronized, Lock, or Atomic classes instead.

Real-World Use Case: Stop a Thread Safely

classServer {
privatevolatilebooleanshutdown=false;

publicvoidstart() {
while (!shutdown) {
// accept requests
        }
    }

publicvoidstop() {
        shutdown =true;
    }
}

Real-Life Analogy

Think of volatile as a shared notice board:

• Anyone who writes updates it directly
• Everyone else reads the latest message
• But multiple people can still write at the same time

👉 Visibility is guaranteed, but race conditions are still possible.

Summary

• Ensures visibility: changes by one thread are immediately seen by others.
• No atomicity: operations like count++ are not thread-safe.
• No mutual exclusion: multiple threads can access simultaneously.
• Prevents instruction reordering for the variable.