Volatile in Java

In the current Java memory model, threads can store variables in local memory (such as the machine's registers), rather than read and write directly in memory. This can cause a thread to modify the value of one variable in main memory, while another thread continues to use its copy of the variable value in the register, resulting in inconsistent data.

To solve this problem, just like in this program, the variable is declared volatile (unstable), which indicates that the JVM, this variable is not stable, each use it to the main memory to read. Generally speaking, the flags shared between tasks in a multitasking environment should be modified with a volatile modifier.

A volatile-modified member variable forces the value of the member variable to be reread from shared memory each time it is accessed by the thread. Also, when a member variable changes, forcing the thread to write the change back to the shared memory. So at any moment, two different threads always see the same value for a member variable.

With the difference between volatile and not volatile, run it, you know.

No volatile:

[Java]View PlainCopy  

2. Package Com.keyword;
6. Public class Testwithoutvolatile {
8. private static Boolean bchanged;
12. public static void Main (string[] args) throws interruptedexception {
14. New Thread () {
18. @Override
20. public Void Run () {
22. for (;;) {  
24. if (bchanged = =!bchanged) {
26. SYSTEM.OUT.PRINTLN ("! =");
28. System.exit (0);
30. }
32. }
34. }
36. }.start ();
38. Thread.Sleep (1);
40. New Thread () {
44. @Override
46. public Void Run () {
48. for (;;) {  
50. bchanged =!bchanged;
52. }
54. }
56. }.start ();
58. }
62. }

After running, the program goes into a dead loop and keeps running.

With volatile:

[Java]View PlainCopy  

2. Package Com.keyword;
6. Public class Testwithvolatile {
8. private static volatile Boolean bchanged;
12. public static void Main (string[] args) throws interruptedexception {
14. New Thread () {
18. @Override
20. public Void Run () {
22. for (;;) {  
24. if (bchanged = =!bchanged) {
26. SYSTEM.OUT.PRINTLN ("! =");
28. System.exit (0);
30. }
32. }
34. }
36. }.start ();
38. Thread.Sleep (1);
40. New Thread () {
44. @Override
46. public Void Run () {
48. for (;;) {  
50. bchanged =!bchanged;
52. }
54. }
56. }.start ();
58. }
62. }

Program Output! =, and then exit immediately.

However, in many cases, with no volatile, no sense of difference, when to use volatile it? Look at the classes in the JDK that use volatile.

For example, variables in Java.util.regex.Pattern:

[Java]View PlainCopy 

1. Private Transient volatile Boolean compiled = false;

Also, the variables of Java.lang.System:

[Java]View PlainCopy 

1. Private static volatile Console cons = null;

In general, when initializing, you need to use volatile.

Variables in the Java.util.Scanner, such as:

[Java]View PlainCopy  

1. Private static volatile Pattern Boolpattern;
2. Private static volatile Pattern Separatorpattern;
3. Private static volatile Pattern LinePattern;

Initialize the Boolpattern code:

[Java]View PlainCopy 

2. Private static Pattern Boolpattern () {
4. Pattern bp = Boolpattern;
6. if (bp = = null)
8. Boolpattern = BP = Pattern.compile (Boolean_pattern,
10. pattern.case_insensitive);
12. return BP;
14. }

Above, you can use synchronized to lock the Boolpattern, but the synchronized overhead is greater than volatile, and volatile is capable of doing the work above.

Volatile does not guarantee atomic manipulation, so it is easy to read dirty data.

Usage Recommendation: Use volatile on member variables accessed by two or more threads. When the variable to be accessed is already in the synchronized code block, or is a constant, you do not have to use the

Volatile in Java