How does the absence of the volatile keyword affect thread behavior when working with an object?

If you do not use the volatile keyword for a variable that is accessed by multiple threads, changes to this variable in one thread may not be visible to other threads due to caching and compiler optimizations. This can lead to a situation where a thread works with an outdated value of the variable, causing synchronization issues and unpredictable program behavior.

The volatile keyword guarantees that reads and writes to the variable will occur directly from main memory, not from the thread's local cache, ensuring visibility of changes across threads.

Example:

class SharedData {
    // Without volatile
    boolean flag = false;

    void writer() {
        flag = true; // change may not be immediately visible to other threads
    }

    void reader() {
        while (!flag) {
            // may loop indefinitely if flag is not updated due to lack of volatile
        }
        // continue work
    }
}

If flag is declared as volatile boolean flag = false;, then changes will be immediately visible to all threads.