Java volatile Keyword

In Java programming, the volatile keyword plays a critical role in managing shared variables across threads. It ensures that changes made to a volatile variable are immediately visible to other threads, thereby enhancing thread safety and preventing subtle concurrency bugs. This comprehensive guide explores the usage, behavior, and best practices associated with the volatile keyword in Java.

On this page

Understanding Shared Memory Model

In multithreaded programming, threads may cache variables locally in their working memory for performance reasons. This can lead to inconsistencies when multiple threads access and modify the same variable concurrently. The Java Memory Model (JMM) defines how threads interact through shared memory.

Role of volatile Keyword

The volatile keyword in Java is used to indicate that a variable's value may be modified by multiple threads concurrently. When a variable is declared as volatile, the following behaviors are guaranteed:

Visibility: Changes to a volatile variable are immediately visible to all threads. When one thread modifies the value of a volatile variable, all other threads see the updated value.

Atomicity: and writes of volatile variables are atomic. This means that operations on volatile variables are indivisible and cannot be interleaved with other operations.

Usage of volatile Keyword

public class SharedResource {
    private volatile boolean flag = false;

    public void setFlag() {
        flag = true;
    }

    public boolean isFlagSet() {
        return flag;
    }
}

java volatile Keyword Example

public class SharedCounter {
    private volatile int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}