Turn!! The role of keyword volatile in Java

Used in multi-threading, synchronous variables. thread to improve efficiency, a member variable (such as a) copy a copy (such as b), the thread of access to a actually access is B. Synchronization of A and B occurs only in certain actions. Thus there is a and B inconsistency. Volatile is used to avoid this situation. Volatile tells the JVM that the variable it modifies does not keep the copy and accesses the main memory directly (that is, a above)

========================= Split Line 1=================================

Copyright notice: When reproduced, please indicate the original source and author information and this statement in the form of hyperlinks.
Http://aleung.blogbus.com/logs/32090434.html

In the Java memory model, there are main memories, and each thread has its own memory (for example, a register). For performance, a thread keeps a copy of the variable to be accessed in its own memory. This will cause the same variable to appear in a moment when the value in the memory of one thread may be inconsistent with the value in the memory of another thread, or the value in main memory.

A variable declared as volatile means that the variable is modified by other threads at any time, so it cannot be cache in the thread memory. The following example shows the effect of volatile:

Java code

2. Public class Stoppabletask extends Thread {
6. Private volatile Boolean pleasestop;
12. public Void Run () {
16. While (!pleasestop) {
20. //Do some stuff ...
24. }
28. }
34. public void Tellmetostop () {
38. Pleasestop = true;
42. }
46. }

If Pleasestop is not declared volatile, when the thread executes run, it checks its own copy and cannot know in time that other threads have called tellmetostop () to modify the value of Pleasestop.

Volatile is generally not a substitute for sychronized, because volatile does not guarantee the atomicity of the operation, even if only i++, is actually composed of multiple atomic operations: Read I; Inc; Write I, if multiple threads execute i++,volatile at the same time can only guarantee that I is the same piece of memory, but it is still possible to write dirty data. If you add atomic wrapper classes with Java 5, you do not need sychronized for operations such as their increase.

Reference:
Http://www.javamex.com/tutorials/synchronization_volatile.shtml
Http://www.javamex.com/tutorials/synchronization_volatile_java_5.shtml
Http://www.ibm.com/developerworks/cn/java/j-jtp06197.html
========================= Split Line 2=================================

I'm afraid it's easiest to explain the difference between volatile and synchronized. Volatile is a variable modifier, while synchronized acts on a code or method; Look at the following three-sentence get code:

Java code

1. int i1;
2. int Geti1 () {return i1;}
3. volatile int i2;
4. int Geti2 ()
5. {return i2;}
6. int i3;
7. Synchronized int Geti3 () {return i3;}
8. Geti1 ()

Gets the number of i1 stored in the current thread. Multiple threads have multiple copies of I1 variables, and these i1 can differ from each other. In other words, another thread may have changed the I1 value within its thread, and this value can be different from the I1 value in the current thread. In fact, Java has an idea called the "main" memory area, where the variable's current "exact value" is stored. Each thread can have its own copy of the variable, and this variable copy value can be different from the "main" memory area. So there is actually a possibility that the I1 value in the "main" memory area is 1, the I1 value in thread 1 is 2, and the I1 value in thread 2 is 3--that the threads 1 and 2 have changed their respective i1 values, and this change has not yet passed to the "main" memory area or other threads.
Geti2 () Gets the i2 value of the "primary" memory area. Variables modified with volatile do not allow a copy of a variable that differs from the "main" memory area. In other words, a variable has to be synchronized in all threads after a volatile modification; any thread changes its value, and all other threads get the same value immediately. As a matter of course, volatile-modified variables are accessed more often than normal variables because the thread has its own variable copy that is more efficient.
Now that the volatile keyword has implemented data synchronization between threads, what synchronized do? Hehe, there are two different points between them. First, the synchronized obtains and releases the monitor-if two threads use the same object lock, the monitor can force the code block to be executed by only one thread at a time-a well-known fact. However, synchronized also synchronizes memory: in fact, synchronized synchronizes the entire thread's memory in the "primary" memory area. Therefore, the Execute Geti3 () method does the following steps:
1. Thread requests to get an object lock that monitors this object (assuming it is not locked, otherwise the thread waits until the lock is released)
2. Thread memory data is eliminated from the "main" memory area read in (Java virtual function optimization This step ...) [I don't know how to express it back, Khan])
3. code block is executed
4. Any change to the variable can now be safely written to the "main" memory area (although the Geti3 () method does not change the value of the variable)
5. Thread release object lock to monitor this object
So volatile is simply synchronizing the value of a variable between the thread memory and the "primary" memory, while the synchronized synchronizes the values of all variables by locking and unlocking a monitor. Obviously synchronized consumes more resources than volatile.

========================= Split Line 3=================================

The volatile keyword believes that the reader of Java Multithreading is aware of its usefulness. The volatile keyword is used to declare simple type variables such as int, float, and Boolean data types. If these simple data types are declared volatile, the operation on them becomes atomic level. But there is a certain limit to this. For example, n in the following example is not an atomic level:

Java code

2. Package mythread;
6. Public class Jointhread extends Thread
8. {
10. public static volatile int n = 0;
12. public Void Run ()
14. {
16. For ( int i = 0; i < ; i + +)
18. Try
20. {
22. n = n + 1;
24. Sleep ( 3); //In order to make the running result more random, delay 3 milliseconds
28. }
30. catch (Exception e)
32. {
34. }
36. }
40. public static void Main (string[] args) throws Exception
42. {
46. Thread threads[] = new thread[ 100];
48. For ( int i = 0; i < threads.length; i + +)
50. //Build 100 threads
52. Threads[i] = new Jointhread ();
54. For ( int i = 0; i < threads.length; i + +)
56. //Run the 100 threads you just created
58. Threads[i].start ();
60. For ( int i = 0; i < threads.length; i + +)
62. //100 threads continue after execution
64. Threads[i].join ();
66. System.out.println ( "n=" + JOINTHREAD.N);
68. }
70. }

If the operation on N is atomic level, the result of the final output should be n=1000, and when the area code is executed, many of the output n are less than 1000, which indicates that n=n+1 is not an atomic level operation. Reason is a simple variable declared volatile if the current value is related to the previous value of the variable, then the volatile keyword does not work, meaning that the following expression is not an atomic operation:

n = n + 1;
n + +;

If you want to turn this situation into an atomic operation, you need to use the Synchronized keyword, as the above code can be changed to the following form:

Java code

2. Package mythread;
6. Public class Jointhread extends Thread
8. {
10. public static int n = 0;
14. public static synchronized Void Inc ()
16. {
18. n + +;
20. }
22. public Void Run ()
24. {
26. For ( int i = 0; i < ; i + +)
28. Try
30. {
32. Inc ();   //n = n + 1 changed to Inc ();
34. Sleep ( 3); //In order to make the running result more random, delay 3 milliseconds
38. }
40. catch (Exception e)
42. {
44. }
46. }
50. public static void Main (string[] args) throws Exception
52. {
56. Thread threads[] = new thread[ 100];
58. For ( int i = 0; i < threads.length; i + +)
60. //Build 100 threads
62. Threads[i] = new Jointhread ();
64. For ( int i = 0; i < threads.length; i + +)
66. //Run the 100 threads you just created
68. Threads[i].start ();
70. For ( int i = 0; i < threads.length; i + +)
72. //100 threads continue after execution
74. Threads[i].join ();
76. System.out.println ( "n=" + JOINTHREAD.N);
78. }
80. }

The code above changed n=n+1 to Inc (), where the INC method uses the Synchronized keyword for method synchronization. Therefore, it is prudent to use the volatile keyword, not as long as the simple type variable using the volatile modifier, all operations on the variable is the original operation, when the value of the variable is determined by its own last, such as n=n+1, n++, etc., the volatile keyword will be invalidated, The action on a variable is atomic only if its value is independent of its previous value , such as n = m + 1, which is the original level. So when using volatile key must be cautious, if you are not sure, you can use synchronized instead of volatile.

This article from Csdn Blog, reproduced please indicate the source: http://blog.csdn.net/orzorz/archive/2009/07/03/4319055.aspx

Turn!! The role of keyword volatile in Java