Скачать или смотреть Understanding the happens-before Relationship in Java: Volatile vs Non-volatile Fields

Explore how volatile and non-volatile fields interact in Java's multithreading model, especially the implications of their `happens-before` relationships.
---
This video is based on the question https://stackoverflow.com/q/62669307/ asked by the user 'pkh7802' ( https://stackoverflow.com/u/13844246/ ) and on the answer https://stackoverflow.com/a/62669967/ provided by the user 'akuzminykh' ( https://stackoverflow.com/u/12323248/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Volatile happens-before relationship when there's mix of volatile and non-volatile fields

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the happens-before Relationship in Java: Volatile vs Non-volatile Fields

In the world of Java programming, particularly when dealing with multithreading, understanding the nuances of volatile and non-volatile fields is crucial. One common question arises when we see a mix of these types of fields in our code and try to reason about their behavior — specifically around the happens-before relationship. Let's take a closer look at a scenario to clarify this concept.

The Problem: Mixed Volatile and Non-volatile Fields

Consider a shared object in Java that contains both volatile and non-volatile fields. In our example, we have a WriteThread and multiple ReadThreads that interact with these fields. The key fields are:

A volatile boolean: stopRequested, which indicates whether a stop has been requested.

Several non-volatile integers: a, b, c, d, e, and f, which hold some numeric values.

The WriteThread modifies these fields, while ReadThreads monitor them. A specific method, waitToBeStopped, is continually checking the state of stopRequested and should react accordingly when it changes.

Sample Code

Here is a simplified look at the relevant portion of the code:

[[See Video to Reveal this Text or Code Snippet]]

When executed, this program produces consistent results from the ReadThreads, always showing values 4, 5, 6, 7, 8, 9 for the non-volatile fields after stopRequested is set to true. This leads us to an important inquiry:

The Inquiry: Why Do We Always See 4,5,6,7,8,9?

Understanding the Java Memory Model

To explain why the outputs are always 4, 5, 6, 7, 8, 9, we need to dive into how the Java Memory Model works with the happens-before relationship.

Visibility Guarantees: When a volatile variable is modified, it establishes a happens-before relationship. This means that any writes that happen before the volatile write are visible to any reads that happen after it.

Write Operations: In our example code, after setting stopRequested to true, further modifications to a, b, and c occur. These writes are not volatile and thus lack the same visibility guarantees that come with a volatile write.

JVM and CPU Behavior: The non-volatile writes (i.e., a, b, c, d, e, f) can be cached by the CPU in a manner that might prevent those updates from being visible to other threads until certain conditions are met. This means that when a ReadThread checks the state of these non-volatile fields, it may still see the old values unless properly synchronized.

Conclusion on Visibility

Your observation is indeed correct: the Java Language Specification does not guarantee that changes after a volatile write will be visible to other threads unless they involve a volatile field. The volatile keyword ensures that the memory is properly synchronized; however, the non-volatile fields can remain inconsistent across threads depending on how the JVM optimizes memory access.

What This Means for Developers

As a Java developer, understanding these relationships is key to avoiding unpredictable behavior in multithreading applications. Here's what you should keep in mind:

Use volatile for variables that multiple threads will read and write frequently.

Consider using synchronized methods or blocks to protect non-volatile shared state.

Be aware of the underlying implementations of your JVM and CPU, as they can affect thread visibility.

By recognizing these principles, you can build more reliable Java applications that effectively handle shared data across threads.

In summary, when dealing with a mix of volatile and non-volatile fields, remember to be cautious of visibility and ordering guarantees — ensuring that your program behaves as intende