blocks|key|184818|text|理想情况下，如果keepRunning不是易失性的，那么线程应该无限期地运行。但是，它确实会在几秒钟后停止。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|184819|184820|如果您在单处理器中运行，或者如果您的系统非常繁忙，则操作系统可能会换出线程，这会导致某些级别的缓存无效。没有volatile并不意味着内存不会被共享，但是出于性能原因，JVM会尽量不同步内存，这样内存就不会被更新。|offset|length|style|CODE|184821|另一件需要注意的事情是，System.out.println(...)是同步的，因为底层的PrintStream会进行同步以停止重叠输出。所以你在主线程中“免费”获得了内存同步。然而，这仍然不能解释为什么读取循环会看到更新。|184822|无论println(...)线路是输入还是输出，您的程序都会在配备英特尔i7的MacBook专业版上的Java6下为我旋转。|184823|184824|有人能用例子来解释一下易失性吗？不是来自JLS的理论。|blockquote|184825|184826|184827|我认为你的例子很好。不确定为什么它不能在删除所有System.out.println(...)语句的情况下工作。这对我很管用。|184828|184829|是同步的易失性替代品吗？它实现原子性了吗？|184830|184831|184832|在内存同步方面，volatile抛出了与synchronized块相同的内存屏障，只是volatile屏障是单向的而不是双向的。volatile读取抛出了加载屏障，而写抛出了存储屏障。synchronized块是一个添加了互斥锁的双向屏障。|184833|然而，就atomicity而言，答案是“视情况而定”。如果您正在从字段读取或写入一个值，那么volatile提供了适当的原子性。然而，递增volatile字段受到这样的限制，即%2B%2B实际上是3个操作:读取、递增、写入。在这种情况或更复杂的互斥情况下，可能需要一个完整的synchronized块。AtomicInteger通过复杂的测试和设置自旋循环解决了%2B%2B问题。|184834|entityMap^0|0|0|1I|8|0|C|N|19|B|0|2|C|0|0|0|0|0|O|N|0|0|0|0|0|8|8|K|C|17|8|1S|8|2K|C|0|4|9|1A|8|1X|8|2G|2|3P|C|43|D|4X|2|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|C|3|D|5|6|7|17|8|@$E|18|F|19|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|1A|8|@$E|1B|F|1C|G|H]|$E|1D|F|1E|G|H]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1F|8|@$E|1G|F|1H|G|H]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1J|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@$E|1N|F|1O|G|H]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|V|3|W|5|P|7|1Q|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1T|8|@$E|1U|F|1V|G|H]|$E|1W|F|1X|G|H]|$E|1Y|F|1Z|G|H]|$E|20|F|21|G|H]|$E|22|F|23|G|H]]|9|@]|A|$]]|$1|11|3|12|5|6|7|24|8|@$E|25|F|26|G|H]|$E|27|F|28|G|H]|$E|29|F|2A|G|H]|$E|2B|F|2C|G|H]|$E|2D|F|2E|G|H]|$E|2F|F|2G|G|H]|$E|2H|F|2I|G|H]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|2J|8|@]|9|@]|A|$]]]|14|$]]

<blockquote>
 Ideally, if keepRunning wasn't volatile, thread should keep on running indefinitely. But, it does stop after few seconds.
</blockquote>

If you are running in a single-processor or if your system is very busy, the OS may be swapping out the threads which causes some levels of cache invalidation. Not having a <code>volatile</code> doesn't mean that memory will not be shared, but the JVM is trying to not synchronize memory if it can for performance reasons so the memory may not be updated.

Another thing to note is that <code>System.out.println(...)</code> is synchronized because the underlying <code>PrintStream</code> does synchronization to stop overlapping output. So you are getting memory synchronization "for free" in the main-thread. This still doesn't explain why the reading loop sees the updates at all however.

Whether the <code>println(...)</code> lines are in or out, your program spins for me under Java6 on a MacBook Pro with an Intel i7.

<blockquote>
 Can anyone explain volatile with example ? Not with theory from JLS.
</blockquote>

I think your example is good. Not sure why it isn't working with all <code>System.out.println(...)</code> statements removed. It works for me.

<blockquote>
 Is volatile substitute for synchronization ? Does it achieve atomicity ?
</blockquote>

In terms of memory synchronization, <code>volatile</code> throws up the same memory barriers as a <code>synchronized</code> block except that the <code>volatile</code> barrier is uni-directional versus bi-directional. <code>volatile</code> reads throw up a load-barrier while writes throw up a store-barrier. A <code>synchronized</code> block is a bi-directional barrier with the addition of mutex locking.

In terms of <code>atomicity</code>, however, the answer is "it depends". If you are reading or writing a value from a field then <code>volatile</code> provides proper atomicity. However, incrementing a <code>volatile</code> field suffers from the limitation that <code>++</code> is actually 3 operations: read, increment, write. In that case or more complex mutex cases, a full <code>synchronized</code> block may be necessary. <code>AtomicInteger</code> solves the <code>++</code> issue with a complicated test-and-set spin-loop.

blocks|key|184847|text|根据volatile和编译器的不同，JVM不一定会带来巨大的变化。然而，对于许多(边缘)情况，这可能是导致变量更改无法被注意到的优化与正确写入变量之间的差异。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|184848|基本上，优化器可以选择将非易失性变量放在寄存器或堆栈中。如果另一个线程在堆中更改了它们或类的原语，另一个线程将继续在堆栈中查找它，它将是陈旧的。|184849|volatile确保这样的优化不会发生，并且所有的读写操作都直接指向堆或其他所有线程都能看到它的地方。|184850|entityMap^0|2|8|0|0|0|8|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

<code>volatile</code> is not going to necessarily create giant changes, depending on the JVM and compiler. However, for many (edge) cases, it can be the difference between optimization causing a variable's changes to fail to be noticed as opposed to them being correctly written.

Basically, an optimizer may choose to put non-volatile variables on registers or on the stack. If another thread changes them in the heap or the classes' primitives, the other thread will keep looking for it on the stack, and it'll be stale.

<code>volatile</code> ensures such optimizations don't happen and all reads and writes are directly to the heap or another place where all threads will see it.

blocks|key|2795912|text|当变量为volatile时，它保证它不会被缓存，并且不同的线程将看到更新后的值。然而，不将其标记为volatile并不能保证情况正好相反。volatile是在很长一段时间内在JVM虚拟机中被破坏的东西之一，并且仍然不总是被很好地理解。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2795913|entityMap^0|4|8|1D|8|1X|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

When a variable is <code>volatile</code>, it is guaranteeing that it will not be cached and that different threads will see the updated value. However, not marking it <code>volatile</code> does not guarantee the opposite. <code>volatile</code> was one of those things that was broken in the JVM for a long time and still not always well understood.

blocks|key|3008527|text|Volatile+-->保证可见性，而不是原子性|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3008528|同步(锁定)+-->保证可见性和原子性(如果处理得当)|3008529|不能替代同步Volatile|3008530|仅当更新引用且不对其执行某些其他操作时，才使用volatile。|3008531|示例：|3008532|volatile+int+i+=+0;

public+void+incrementI(){
+++i%2B%2B;
}|code-block|syntax|javascript|3008533|如果不使用同步或AtomicInteger，将不是线程安全的，因为递增是一种复合操作。|3008534|3008535|为什么程序不能无限期运行？|blockquote|3008536|3008537|3008538|嗯，这取决于不同的情况。在大多数情况下，JVM足够智能，可以刷新内容。|3008539|Correct+use+of+volatile讨论了易失性的各种可能的用法。正确地使用易失性是很棘手的，我会说“如果有疑问，就省略它”，使用同步化的块。|offset|length|3008540|另外：|3008541|同步块可以用来代替，但反之不是真的volatile。|style|BOLD|3008542|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ibm.com/developerworks/java/library/j-jtp06197/index.html^0|0|0|0|0|0|0|0|0|0|0|0|0|0|N|0|0|0|0|9|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1H|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1I|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1J|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1K|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1L|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1O|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1S|8|@]|9|@$10|1T|11|1U|1|1V]]|A|$]]|$1|12|3|13|5|6|7|1W|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1X|8|@$10|1Y|11|1Z|16|17]]|9|@]|A|$]]|$1|18|3|-4|5|6|7|20|8|@]|9|@]|A|$]]]|19|$1A|$5|1B|1C|1D|A|$1E|1F]]]]

Volatile --> Guarantees visibility and NOT atomicity

Synchronization (Locking) --> Guarantees visibility and atomicity (if done properly)

Volatile is not a substitute for synchronization

Use volatile only when you are updating the reference and not performing some other operations on it.

Example:

<pre><code>volatile int i = 0;

public void incrementI(){
 i++;
}
</code></pre>

will not be thread safe without use of synchronization or AtomicInteger as incrementing is an compound operation.

<blockquote>
 Why program does not run indefinitely?
</blockquote>

Well that depends on various circumstances. In most cases JVM is smart enough to flush the contents.

<a href="http://www.ibm.com/developerworks/java/library/j-jtp06197/index.html" rel="noreferrer">Correct use of volatile</a> discusses various possible uses of volatile. Using volatile correctly is tricky, I would say "When in doubt, Leave it out", use synchronized block instead.

Also:

synchronized block can be used in place of volatile but the inverse is not true.

blocks|key|2795995|text|对于您的特定示例:如果没有声明为，服务器JVM可以将keepRunning变量提升到循环之外，因为它没有在循环中修改(将其变成无限循环)，但是客户机JVM不会。这就是为什么你会看到不同的结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|2795996|关于易失性变量的一般解释如下：|2795997|当一个字段被声明为volatile时，编译器和运行时会注意到这个变量是共享的，对它的操作不应该与其他内存操作一起重新排序。易失性变量不会缓存在寄存器或缓存中，因为它们对其他处理器是隐藏的，因此读取易失性变量总是返回任何线程的最新写入。|2795998|易失性变量的可见性影响超出了易失性变量本身的值。当线程A写入易失性变量，随后线程B读取该变量时，在写入易失性变量之前对A可见的所有变量的值在读取易失性变量之后对B变为可见。|2795999|易失性变量最常见的用途是作为完成、中断或状态标志：|2796000|++volatile+boolean+flag;
++while+(!flag)++{
+++++//+do+something+untill+flag+is+true
++}|code-block|syntax|javascript|2796001|易失性变量可以用于其他类型的状态信息，但在尝试此操作时需要更加小心。例如，易失性的语义不足以使增量操作(count%2B%2B)成为原子，除非您能保证变量只从单个线程写入。|2796002|锁可以同时保证可见性和原子性；易失性变量只能保证可见性。|2796003|只有在满足以下所有条件时，才能使用易失性变量：|2796004|2796005|写入变量不依赖于它的当前值，或者您可以确保只有一个线程更新该值；|unordered-list-item|2796006|该变量不会与其他状态变量一起参与不变量；在访问该变量时，由于任何其他原因，不需要|2796007|锁定。|2796008|2796009|调试技巧：确保在调用-server时指定JVM命令行开关，即使是在开发和测试时也是如此。服务器JVM比客户端JVM执行更多的优化，比如将未在循环中修改的变量提升到循环之外；在开发环境(客户端JVM)中看起来可以工作的代码可能会在部署环境(服务器JVM)中中断。|2796010|这是你能找到的关于这个主题的最好的书"Java+Concurrency+in+Practice"的摘录。|2796011|entityMap|0|LINK|mutability|MUTABLE|url|http://jcip.net/^0|G|11|Q|B|0|0|9|8|0|0|0|0|1G|7|0|0|S|0|0|0|0|0|0|0|0|4|A|7|0|I|U|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1P|8|@]|E|@]|F|$]]|$1|I|3|J|5|6|7|1Q|8|@$9|1R|A|1S|B|D]]|E|@]|F|$]]|$1|K|3|L|5|6|7|1T|8|@]|E|@]|F|$]]|$1|M|3|N|5|6|7|1U|8|@]|E|@]|F|$]]|$1|O|3|P|5|Q|7|1V|8|@]|E|@]|F|$R|S]]|$1|T|3|U|5|6|7|1W|8|@$9|1X|A|1Y|B|D]]|E|@]|F|$]]|$1|V|3|W|5|6|7|1Z|8|@$9|20|A|21|B|C]]|E|@]|F|$]]|$1|X|3|Y|5|6|7|22|8|@]|E|@]|F|$]]|$1|Z|3|-4|5|6|7|23|8|@]|E|@]|F|$]]|$1|10|3|11|5|12|7|24|8|@]|E|@]|F|$]]|$1|13|3|14|5|12|7|25|8|@]|E|@]|F|$]]|$1|15|3|16|5|12|7|26|8|@]|E|@]|F|$]]|$1|17|3|-4|5|6|7|27|8|@]|E|@]|F|$]]|$1|18|3|19|5|6|7|28|8|@$9|29|A|2A|B|C]|$9|2B|A|2C|B|D]]|E|@]|F|$]]|$1|1A|3|1B|5|6|7|2D|8|@]|E|@$9|2E|A|2F|1|2G]]|F|$]]|$1|1C|3|-4|5|6|7|2H|8|@]|E|@]|F|$]]]|1D|$1E|$5|1F|1G|1H|F|$1I|1J]]]]

For your particular example: if not declared volatile the server JVM could hoist the <code>keepRunning</code> variable out of the loop because it is not modified in the loop (turning it into an infinite loop), but the client JVM would not. That is why you see different results.

General explanation about volatile variables follows:

When a field is declared <code>volatile</code>, the compiler and runtime are put on notice that this variable is shared and that operations on it should not be reordered with other memory operations. Volatile variables are not cached in registers or in caches where they are hidden from other processors, so a read of a volatile variable always returns the most recent write by any thread. 

The visibility effects of volatile variables extend beyond the value of the volatile variable itself. When thread A writes to a volatile variable and subsequently thread B reads that same variable, the values of all variables that were visible to A prior to writing to the volatile variable become visible to B after reading the volatile variable.

The most common use for volatile variables is as a completion, interruption, or status flag:

<pre><code> volatile boolean flag;
 while (!flag) {
 // do something untill flag is true
 }
</code></pre>

Volatile variables can be used for other kinds of state information, but more care is required when attempting this. For example, the semantics of volatile are not strong enough to make the increment operation (<code>count++</code>) atomic, unless you can guarantee that the variable is written only from a single thread.

Locking can guarantee both visibility and atomicity; volatile variables can only guarantee visibility.

You can use volatile variables only when all the following criteria are met: 

<ul>
<li>Writes to the variable do not depend on its current value, or you can
ensure that only a single thread ever updates the value;</li>
<li>The variable does not participate in invariants with other state variables; and</li>
<li>Locking is not required for any other reason while the variable is being accessed.</li>
</ul>

Debugging tip: be sure to always specify the <code>-server</code> JVM command line switch when invoking the JVM, even for development and testing. The server JVM performs more optimization than the client JVM, such as hoisting variables out of a loop that are not modified in the loop; code that might appear to work in the development environment (client JVM) can break in the deployment environment 
(server JVM).

This is an excerpt from <a href="http://jcip.net/" rel="noreferrer">"Java Concurrency in Practice"</a>, the best book you can find on this subject.

blocks|key|2796029|text|被声明为易失性的对象通常用于在线程之间传递状态信息，以确保CPU缓存被更新，即保持同步。在存在易失性字段的情况下，CPU指令、内存屏障(通常称为记忆条或栅栏)被发出以使用易失性字段的值的变化来更新CPU缓存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2796030|volatile修饰符告诉编译器，由volatile修改的变量可能会被程序的其他部分意外更改。|2796031|volatile变量只能在线程上下文中使用。请参阅示例here|offset|length|2796032|entityMap|0|LINK|mutability|MUTABLE|url|http://www.youtube.com/watch?v=y8_jrkHEZpg&list=PLrUFyg1unBb9bhxd9ck0LEL89UB_G6-ZJ&index=5^0|0|0|R|4|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Objects that are declared as volatile are usually used to communicate state information among threads,To ensure CPU caches are updated, that is, kept in sync, in the presence of volatile fields, a CPU instruction, a memory barrier, often called a membar or fence, is emitted to update CPU caches with a change in a volatile field’s value.

The volatile modifier tells the compiler that the variable modified by volatile can be changed unexpectedly by other parts of your program.

The volatile variable must be used in Thread Context only. see the example <a href="http://www.youtube.com/watch?v=y8_jrkHEZpg&amp;list=PLrUFyg1unBb9bhxd9ck0LEL89UB_G6-ZJ&amp;index=5" rel="nofollow">here</a>

blocks|key|184986|text|我稍微修改了一下你的例子。现在使用keepRunning作为易失性和非易失性成员的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|184987|class+TestVolatile+extends+Thread{
++++//volatile
++++boolean+keepRunning+=+true;

++++public+void+run()+{
++++++++long+count=0;
++++++++while+(keepRunning)+{
++++++++++++count%2B%2B;
++++++++}

++++++++System.out.println("Thread+terminated."+%2B+count);
++++}

++++public+static+void+main(String[]+args)+throws+InterruptedException+{
++++++++TestVolatile+t+=+new+TestVolatile();
++++++++t.start();
++++++++Thread.sleep(1000);
++++++++System.out.println("after+sleeping+in+main");
++++++++t.keepRunning+=+false;
++++++++t.join();
++++++++System.out.println("keepRunning+set+to+"+%2B+t.keepRunning);
++++}
}|code-block|syntax|javascript|184988|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I have modified your example slightly. Now use the example with keepRunning as volatile and non volatile member :

<pre><code>class TestVolatile extends Thread{
 //volatile
 boolean keepRunning = true;

 public void run() {
 long count=0;
 while (keepRunning) {
 count++;
 }

 System.out.println("Thread terminated." + count);
 }

 public static void main(String[] args) throws InterruptedException {
 TestVolatile t = new TestVolatile();
 t.start();
 Thread.sleep(1000);
 System.out.println("after sleeping in main");
 t.keepRunning = false;
 t.join();
 System.out.println("keepRunning set to " + t.keepRunning);
 }
}
</code></pre>

blocks|key|2796121|text|请在下面找到解决方案，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2796122|这个变量的值永远不会被线程本地缓存:所有的读写操作都会直接进入“主存”。易失性强制线程每次都更新原始变量。|2796123|public+class+VolatileDemo+{

++++private+static+volatile+int+MY_INT+=+0;

++++public+static+void+main(String[]+args)+{

++++++++ChangeMaker+changeMaker+=+new+ChangeMaker();
++++++++changeMaker.start();

++++++++ChangeListener+changeListener+=+new+ChangeListener();
++++++++changeListener.start();

++++}

++++static+class+ChangeMaker+extends+Thread+{

++++++++@Override
++++++++public+void+run()+{
++++++++++++while+(MY_INT+<+5){
++++++++++++++++System.out.println("Incrementing+MY_INT+"%2B+%2B%2BMY_INT);
++++++++++++++++try{
++++++++++++++++++++Thread.sleep(1000);
++++++++++++++++}catch(InterruptedException+exception)+{
++++++++++++++++++++exception.printStackTrace();
++++++++++++++++}
++++++++++++}
++++++++}
++++}

++++static+class+ChangeListener+extends+Thread+{

++++++++int+local_value+=+MY_INT;

++++++++@Override
++++++++public+void+run()+{
++++++++++++while+(+MY_INT+<+5){
++++++++++++++++if(+local_value!=+MY_INT){
++++++++++++++++++++System.out.println("Got+Change+for+MY_INT+"%2B+MY_INT);
++++++++++++++++++++local_value+=+MY_INT;
++++++++++++++++}
++++++++++++}
++++++++}
++++}

}|code-block|syntax|javascript|2796124|请参考此链接http://java.dzone.com/articles/java-volatile-keyword-0以更清楚地了解它。|offset|length|2796125|entityMap|0|LINK|mutability|MUTABLE|url|http://java.dzone.com/articles/java-volatile-keyword-0^0|0|0|0|6|1I|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Please find the solution below,

The value of this variable will never be cached thread-locally: all reads and writes will go straight to "main memory". The volatile force the thread to update the original variable for each time. 

<pre><code>public class VolatileDemo {

 private static volatile int MY_INT = 0;

 public static void main(String[] args) {

 ChangeMaker changeMaker = new ChangeMaker();
 changeMaker.start();

 ChangeListener changeListener = new ChangeListener();
 changeListener.start();

 }

 static class ChangeMaker extends Thread {

 @Override
 public void run() {
 while (MY_INT &lt; 5){
 System.out.println("Incrementing MY_INT "+ ++MY_INT);
 try{
 Thread.sleep(1000);
 }catch(InterruptedException exception) {
 exception.printStackTrace();
 }
 }
 }
 }

 static class ChangeListener extends Thread {

 int local_value = MY_INT;

 @Override
 public void run() {
 while ( MY_INT &lt; 5){
 if( local_value!= MY_INT){
 System.out.println("Got Change for MY_INT "+ MY_INT);
 local_value = MY_INT;
 }
 }
 }
 }

}
</code></pre>

Please refer this link <a href="http://java.dzone.com/articles/java-volatile-keyword-0" rel="nofollow">http://java.dzone.com/articles/java-volatile-keyword-0</a> to get more clarity in it.

blocks|key|3008779|text|：Volatile关键字适用于变量。Java中的volatile关键字保证了始终从主内存而不是从Thread的本地缓存读取volatile变量的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3008780|Access_Modifier+volatile+DataType+Variable_Name;|code-block|syntax|javascript|3008781|易失性字段:指示VM多个线程可能尝试同时访问/更新字段的值。到一种特殊的实例变量，它必须在所有具有修改值的线程之间共享。与静态(类)变量类似，只有一个易失性值的副本缓存在主存中，因此在执行任何ALU操作之前，每个线程都必须在ALU操作后从主存中读取更新值，并将其直接写入主存。(对易失性变量v的写入会与任何线程对v的所有后续读取同步)这意味着对易失性变量的更改始终对其他线程可见。|offset|length|style|BOLD|3008782|​|3008783|📷|atomic|3008784|3008785|这里是nonvoltaile+variable如果线程t1改变了t1缓存中的值，线程t2不能访问改变的值，直到t1写，t2从主存储器读取最近修改的值，这可能导致Data-Inconsistancy。|CODE|3008786|3008787|++-+assembler|blockquote|3008788|3008789|%2B--------------%2B--------%2B-------------------------------------%2B+%7C标志名称%7C值%7C解释%7C%2B无法缓存。%7C+%2B--------------%2B--------%2B-------------------------------------%2B+%7CACC_TRANSIENT+%7C+0x0080+%7C声明为瞬态；不是由永久对象管理器写入或%7C读取。%7C+%2B--------------%2B--------%2B-------------------------------------%2B|3008790|3008791|Shared+Variables：可以在线程之间共享的内存称为共享内存或堆内存。所有实例字段、静态字段和数组元素都存储在堆内存中。|3008792|Synchronization：synchronized适用于方法、块。一次只允许在对象上执行一个线程。如果t1获得了控制权，那么剩余的线程必须等待，直到它释放控制权。|3008793|示例：|3008794|public+class+VolatileTest+implements+Runnable+{

++++private+static+final+int+MegaBytes+=+10241024;

++++private+static+final+Object+counterLock+=+new+Object();
++++private+static+int+counter+=+0;
++++private+static+volatile+int+counter1+=+0;

++++private+volatile+int+counter2+=+0;
++++private+int+counter3+=+0;

++++@Override
++++public+void+run()+{
++++++++for+(int+i+=+0;+i+<+5;+i%2B%2B)+{
++++++++++++concurrentMethodWrong();
++++++++}

++++}

++++void+addInstanceVolatile()+{
++++++++synchronized+(counterLock)+{
++++++++++++counter2+=+counter2+%2B+1;
++++++++++++System.out.println(+Thread.currentThread().getName()+%2B"\t\t+«+InstanceVolatile+::+"%2B+counter2);
++++++++}
++++}

++++public+void+concurrentMethodWrong()+{
++++++++counter+=+counter+%2B+1;
++++++++System.out.println(+Thread.currentThread().getName()+%2B"+«+Static+::+"%2B+counter);
++++++++sleepThread(+1/4+);

++++++++counter1+=+counter1+%2B+1;
++++++++System.out.println(+Thread.currentThread().getName()+%2B"\t+«+StaticVolatile+::+"%2B+counter1);
++++++++sleepThread(+1/4+);

++++++++addInstanceVolatile();
++++++++sleepThread(+1/4+);

++++++++counter3+=+counter3+%2B+1;
++++++++sleepThread(+1/4+);
++++++++System.out.println(+Thread.currentThread().getName()+%2B"\t\t\t\t\t+«+Instance+::+"%2B+counter3);
++++}
++++public+static+void+main(String[]+args)+throws+InterruptedException+{
++++++++Runtime+runtime+=+Runtime.getRuntime();

++++++++int+availableProcessors+=+runtime.availableProcessors();
++++++++System.out.println("availableProcessors+::+"%2BavailableProcessors);
++++++++System.out.println("MAX+JVM+will+attempt+to+use+:+"%2B+runtime.maxMemory()+/+MegaBytes+);
++++++++System.out.println("JVM+totalMemory+also+equals+to+initial+heap+size+of+JVM+:+"%2B+runtime.totalMemory()+/+MegaBytes+);
++++++++System.out.println("Returns+the+amount+of+free+memory+in+the+JVM+:+"%2B+untime.freeMemory()+/+MegaBytes+);
++++++++System.out.println("+=====+-----+=====+");

++++++++VolatileTest+volatileTest+=+new+VolatileTest();
++++++++Thread+t1+=+new+Thread(+volatileTest+);
++++++++t1.start();

++++++++Thread+t2+=+new+Thread(+volatileTest+);
++++++++t2.start();

++++++++Thread+t3+=+new+Thread(+volatileTest+);
++++++++t3.start();

++++++++Thread+t4+=+new+Thread(+volatileTest+);
++++++++t4.start();

++++++++Thread.sleep(+10+);;

++++++++Thread+optimizeation+=+new+Thread()+{
++++++++++++@Override+public+void+run()+{
++++++++++++++++System.out.println("Thread+Start.");

++++++++++++++++Integer+appendingVal+=+volatileTest.counter2+%2B+volatileTest.counter2+%2B+volatileTest.counter2;

++++++++++++++++System.out.println("End+of+Thread."+%2B+appendingVal);
++++++++++++}
++++++++};
++++++++optimizeation.start();
++++}

++++public+void+sleepThread(+long+sec+)+{
++++++++try+{
++++++++++++Thread.sleep(+sec+*+1000+);
++++++++}+catch+(InterruptedException+e)+{
++++++++++++e.printStackTrace();
++++++++}
++++}
}|3008795|3008796|+StaticClass+Field+与+VolatileInstance+Field+-两者都不是由线程缓存的|3008797|3008798|3008799|3008800|静态字段对所有线程都是通用的，并存储在方法区域中。静态和易失性不使用。静态字段不能主要与存储在堆区域中的实例变量一起使用serialized.|unordered-list-item|3008801|Volatile。volatile的主要用途是维护所有线程的更新值。实例易失性字段可以为Serialized.|3008802|3008803|@查看|3008804|3008805|Volatile+Vs+Static+in+java|3008806|System+with+multiple+cores+sharing+an+L2+cache|3008807|JVM+memory+model|3008808|3008809|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/11a99857e951b69aff674fd0b8c057b0.png|imageAlt|1|LINK|MUTABLE|url|http://hg.openjdk.java.net/icedtea/jdk7/hotspot/file/d9f0ed25f7ed/src/share/vm/opto/memnode.cpp#l2862|2|https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4.1|3|https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-3.html#jvms-3.14|4|https://stackoverflow.com/a/31651945/5081877|5|https://stackoverflow.com/a/7943472/5081877|6|https://www.ibm.com/developerworks/aix/library/au-aix-multicore-multiprocessor/index.html#fig3|7|https://stackoverflow.com/a/31103100/5081877^0|0|0|4N|N|0|0|0|1|0|0|0|3|K|28|I|0|0|4|9|1|0|0|0|0|0|G|0|G|2|0|0|F|3|0|0|0|0|7|B|T|E|J|1|0|0|0|0|0|18|A|4|0|0|0|0|0|Q|5|0|0|1A|6|0|0|G|7|0|0^^$0|@$1|2|3|4|5|6|7|2N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|2O|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|2P|8|@$I|2Q|J|2R|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|2S|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|2T|8|@]|9|@$I|2U|J|2V|1|2W]]|A|$]]|$1|R|3|N|5|6|7|2X|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|2Y|8|@$I|2Z|J|30|K|U]|$I|31|J|32|K|U]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|33|8|@]|9|@]|A|$]]|$1|W|3|X|5|Y|7|34|8|@]|9|@$I|35|J|36|1|37]]|A|$]]|$1|Z|3|-4|5|6|7|38|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|39|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|3A|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|3B|8|@$I|3C|J|3D|K|U]]|9|@$I|3E|J|3F|1|3G]]|A|$]]|$1|15|3|16|5|6|7|3H|8|@]|9|@$I|3I|J|3J|1|3K]]|A|$]]|$1|17|3|18|5|6|7|3L|8|@]|9|@]|A|$]]|$1|19|3|1A|5|D|7|3M|8|@]|9|@]|A|$E|F]]|$1|1B|3|-4|5|6|7|3N|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|Y|7|3O|8|@$I|3P|J|3Q|K|U]|$I|3R|J|3S|K|U]|$I|3T|J|3U|K|L]]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|3V|8|@]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|3W|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|3X|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|1J|7|3Y|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|1J|7|3Z|8|@]|9|@$I|40|J|41|1|42]]|A|$]]|$1|1M|3|-4|5|6|7|43|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|44|8|@]|9|@]|A|$]]|$1|1P|3|-4|5|6|7|45|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|1J|7|46|8|@]|9|@$I|47|J|48|1|49]]|A|$]]|$1|1S|3|1T|5|1J|7|4A|8|@]|9|@$I|4B|J|4C|1|4D]]|A|$]]|$1|1U|3|1V|5|1J|7|4E|8|@]|9|@$I|4F|J|4G|1|4H]]|A|$]]|$1|1W|3|-4|5|6|7|4I|8|@]|9|@]|A|$]]|$1|1X|3|-4|5|6|7|4J|8|@]|9|@]|A|$]]]|1Y|$1Z|$5|20|21|22|A|$23|24|25|-4]]|26|$5|27|21|28|A|$29|2A]]|2B|$5|27|21|28|A|$29|2C]]|2D|$5|27|21|28|A|$29|2E]]|2F|$5|27|21|28|A|$29|2G]]|2H|$5|27|21|28|A|$29|2I]]|2J|$5|27|21|28|A|$29|2K]]|2L|$5|27|21|28|A|$29|2M]]]]

<a href="https://docs.oracle.com/cd/E19683-01/806-5222/codingpractices-1/index.html" rel="noreferrer"><code>Variable Volatile</code></a>: Volatile Keyword is applicable to variables. volatile keyword in Java guarantees that value of the volatile variable will always be read from main memory and not from Thread's local cache.

<pre><code>Access_Modifier volatile DataType Variable_Name;
</code></pre>

Volatile Field: An indication to the VM that multiple threads may try to access/update the field's value at the same time. To a special kind of instance variables which has to shared among all the threads with Modified value. Similar to Static(Class) variable, Only one copy of volatile value is cached in main memory, So that before doing any ALU Operations each thread has to read the updated value from Main memory after ALU operation it has to write to main memory direclty. (A write to a volatile variable v synchronizes-with all subsequent reads of v by any thread) This means that changes to a volatile variable are always visible to other threads.

<a href="https://i.stack.imgur.com/xiXRN.png" rel="noreferrer"><img src="https://i.stack.imgur.com/xiXRN.png" alt="enter image description here"></a>

Here to a <code>nonvoltaile variable</code> if Thread t1 changes the value in t1's cache, Thread t2 can't access the changed value untill t1 writes, t2 read from main memory for the most recent modified value, which may lead to <code>Data-Inconsistancy</code>.

<blockquote>
 <a href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.5-200-A.1" rel="noreferrer">volatile cannot be cached</a> - <a href="http://hg.openjdk.java.net/icedtea/jdk7/hotspot/file/d9f0ed25f7ed/src/share/vm/opto/memnode.cpp#l2862" rel="noreferrer">assembler</a>

<pre><code> +--------------+--------+-------------------------------------+
 | Flag Name | Value | Interpretation |
 +--------------+--------+-------------------------------------+
 | ACC_VOLATILE | 0x0040 | Declared volatile; cannot be cached.|
 +--------------+--------+-------------------------------------+
 |ACC_TRANSIENT | 0x0080 | Declared transient; not written or |
 | | | read by a persistent object manager.|
 +--------------+--------+-------------------------------------+
</code></pre>
</blockquote>

<a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4.1" rel="noreferrer"><code>Shared Variables</code></a>:
Memory that can be shared between threads is called shared memory or heap memory. All instance fields, static fields, and array elements are stored in heap memory.

<a href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-3.html#jvms-3.14" rel="noreferrer">Synchronization</a>: synchronized is applicable to methods, blocks. allows to execute only 1-thread at a time on object. If t1 takes control, then remaining threads has to wait untill it release the control.

Example:



<pre class="lang-java prettyprint-override"><code>public class VolatileTest implements Runnable {

 private static final int MegaBytes = 10241024;

 private static final Object counterLock = new Object();
 private static int counter = 0;
 private static volatile int counter1 = 0;

 private volatile int counter2 = 0;
 private int counter3 = 0;

 @Override
 public void run() {
 for (int i = 0; i &lt; 5; i++) {
 concurrentMethodWrong();
 }

 }

 void addInstanceVolatile() {
 synchronized (counterLock) {
 counter2 = counter2 + 1;
 System.out.println( Thread.currentThread().getName() +"\t\t « InstanceVolatile :: "+ counter2);
 }
 }

 public void concurrentMethodWrong() {
 counter = counter + 1;
 System.out.println( Thread.currentThread().getName() +" « Static :: "+ counter);
 sleepThread( 1/4 );

 counter1 = counter1 + 1;
 System.out.println( Thread.currentThread().getName() +"\t « StaticVolatile :: "+ counter1);
 sleepThread( 1/4 );

 addInstanceVolatile();
 sleepThread( 1/4 );

 counter3 = counter3 + 1;
 sleepThread( 1/4 );
 System.out.println( Thread.currentThread().getName() +"\t\t\t\t\t « Instance :: "+ counter3);
 }
 public static void main(String[] args) throws InterruptedException {
 Runtime runtime = Runtime.getRuntime();

 int availableProcessors = runtime.availableProcessors();
 System.out.println("availableProcessors :: "+availableProcessors);
 System.out.println("MAX JVM will attempt to use : "+ runtime.maxMemory() / MegaBytes );
 System.out.println("JVM totalMemory also equals to initial heap size of JVM : "+ runtime.totalMemory() / MegaBytes );
 System.out.println("Returns the amount of free memory in the JVM : "+ untime.freeMemory() / MegaBytes );
 System.out.println(" ===== ----- ===== ");

 VolatileTest volatileTest = new VolatileTest();
 Thread t1 = new Thread( volatileTest );
 t1.start();

 Thread t2 = new Thread( volatileTest );
 t2.start();

 Thread t3 = new Thread( volatileTest );
 t3.start();

 Thread t4 = new Thread( volatileTest );
 t4.start();

 Thread.sleep( 10 );;

 Thread optimizeation = new Thread() {
 @Override public void run() {
 System.out.println("Thread Start.");

 Integer appendingVal = volatileTest.counter2 + volatileTest.counter2 + volatileTest.counter2;

 System.out.println("End of Thread." + appendingVal);
 }
 };
 optimizeation.start();
 }

 public void sleepThread( long sec ) {
 try {
 Thread.sleep( sec * 1000 );
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
}
</code></pre>



<blockquote>
 Static[<code>Class Field</code>] vs Volatile[<code>Instance Field</code>] - Both are not cached by threads
 
 <ul>
 <li>Static fields are common to all threads and get stored in Method Area. Static with volatile no use. Static field cant be serialized.</li>
 <li>Volatile mainly used with instance variable which get stored in heap area. The main use of volatile is to maintain updated value over all the Threads. instance volatile field can be <a href="https://stackoverflow.com/a/31651945/5081877">Serialized</a>.</li>
 </ul>
</blockquote>

@see

<ul>
<li><a href="https://stackoverflow.com/a/7943472/5081877">Volatile Vs Static in java</a></li>
<li><a href="https://www.ibm.com/developerworks/aix/library/au-aix-multicore-multiprocessor/index.html#fig3" rel="noreferrer">System with multiple cores sharing an L2 cache</a></li>
<li><a href="https://stackoverflow.com/a/31103100/5081877">JVM memory model</a></li>
</ul>

blocks|key|182326|text|volatile关键字告诉JVM它可能会被另一个线程修改。每个线程都有自己的堆栈，因此它可以访问自己的变量副本。创建线程时，它会将所有可访问变量的值复制到自己的内存中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|182327|public+class+VolatileTest+{
++++private+static+final+Logger+LOGGER+=+MyLoggerFactory.getSimplestLogger();

++++private+static+volatile+int+MY_INT+=+0;

++++public+static+void+main(String[]+args)+{
++++++++new+ChangeListener().start();
++++++++new+ChangeMaker().start();
++++}

++++static+class+ChangeListener+extends+Thread+{
++++++++@Override
++++++++public+void+run()+{
++++++++++++int+local_value+=+MY_INT;
++++++++++++while+(+local_value+<+5){
++++++++++++++++if(+local_value!=+MY_INT){
++++++++++++++++++++LOGGER.log(Level.INFO,"Got+Change+for+MY_INT+:+{0}",+MY_INT);
+++++++++++++++++++++local_value=+MY_INT;
++++++++++++++++}
++++++++++++}
++++++++}
++++}

++++static+class+ChangeMaker+extends+Thread{
++++++++@Override
++++++++public+void+run()+{

++++++++++++int+local_value+=+MY_INT;
++++++++++++while+(MY_INT+<5){
++++++++++++++++LOGGER.log(Level.INFO,+"Incrementing+MY_INT+to+{0}",+local_value%2B1);
++++++++++++++++MY_INT+=+%2B%2Blocal_value;
++++++++++++++++try+{
++++++++++++++++++++Thread.sleep(500);
++++++++++++++++}+catch+(InterruptedException+e)+{+e.printStackTrace();+}
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|182328|在使用和不使用易失性的情况下尝试此示例。|182329|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The volatile keyword tells the JVM that it may be modified by another thread.
Each thread has its own stack, and so its own copy of variables it can access. When a thread is created, it copies the value of all accessible variables in its own memory. 

<pre><code>public class VolatileTest {
 private static final Logger LOGGER = MyLoggerFactory.getSimplestLogger();

 private static volatile int MY_INT = 0;

 public static void main(String[] args) {
 new ChangeListener().start();
 new ChangeMaker().start();
 }

 static class ChangeListener extends Thread {
 @Override
 public void run() {
 int local_value = MY_INT;
 while ( local_value &lt; 5){
 if( local_value!= MY_INT){
 LOGGER.log(Level.INFO,"Got Change for MY_INT : {0}", MY_INT);
 local_value= MY_INT;
 }
 }
 }
 }

 static class ChangeMaker extends Thread{
 @Override
 public void run() {

 int local_value = MY_INT;
 while (MY_INT &lt;5){
 LOGGER.log(Level.INFO, "Incrementing MY_INT to {0}", local_value+1);
 MY_INT = ++local_value;
 try {
 Thread.sleep(500);
 } catch (InterruptedException e) { e.printStackTrace(); }
 }
 }
 }
}
</code></pre>

try out this example with and without volatile.

blocks|key|2796330|text|有很多很好的例子，但我只想补充说，有许多场景需要volatile，所以没有一个具体的例子来规范它们。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2796331|2796332|您可以使用volatile强制所有线程从主内存中获取变量的最新值。|ordered-list-item|2796333|您可以使用synchronization来保护关键数据|2796334|您可以使用Lock+API<代码>H210<代码>H111您可以使用<代码>D12变量<代码>H213<代码>G214|2796335|2796336|查看更多Java+volatile+examples。|2796337|entityMap|0|LINK|mutability|MUTABLE|url|https://javatutorial.net/java-volatile-example^0|O|8|0|0|5|8|0|5|F|0|5|4|0|0|4|M|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|11|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|J|3|K|5|I|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|L|3|M|5|I|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1C|8|@]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|Q|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

Lot's of great examples, but I just want to add that there are a number of scenarios where <code>volatile</code> is required so there is no one concrete example to rule them a.

<ol>
<li>You can use <code>volatile</code> to force all threads to get latest value of the variable from main memory.</li>
<li>You can use <code>synchronization</code> to guard critical data</li>
<li>You can use <code>Lock</code> API</li>
<li>You can use <code>Atomic</code> variables</li>
</ol>

Check it out for more <a href="https://javatutorial.net/java-volatile-example" rel="nofollow noreferrer">Java volatile examples</a>.

blocks|key|3008953|text|public+class+VolatileDemo+{
++++static+class+Processor+{
++++++++//without+volatile+program+keeps+running+on+my+platform
++++++++private+boolean+flag+=+false;

++++++++public+void+setFlag()+{
++++++++++++System.out.println("setting+flag+true");
++++++++++++this.flag+=+true;
++++++++}

++++++++public+void+process()+{
++++++++++++while(!flag)+{
++++++++++++++++int+x+=+5;
++++++++++++++++//+using+sleep+or+sout+will+end+the+program+without+volatile.
++++++++++++++++//+Probably+these+operations,+cause+thread+to+be+rescheduled,+read+from+memory.+Thus+read+new+flag+value+and+end.
++++++++++++}

++++++++++++System.out.println("Ending");
++++++++}
++++}

++++public+static+void+main(String[]+args)+throws+InterruptedException+{
++++++++Processor+processor+=+new+Processor();
++++++++Thread+t1+=+new+Thread(processor::process);

++++++++t1.start();

++++++++Thread.sleep(2000);
++++++++processor.setFlag();

++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3008954|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class VolatileDemo {
 static class Processor {
 //without volatile program keeps running on my platform
 private boolean flag = false;

 public void setFlag() {
 System.out.println(&quot;setting flag true&quot;);
 this.flag = true;
 }

 public void process() {
 while(!flag) {
 int x = 5;
 // using sleep or sout will end the program without volatile.
 // Probably these operations, cause thread to be rescheduled, read from memory. Thus read new flag value and end.
 }

 System.out.println(&quot;Ending&quot;);
 }
 }

 public static void main(String[] args) throws InterruptedException {
 Processor processor = new Processor();
 Thread t1 = new Thread(processor::process);

 t1.start();

 Thread.sleep(2000);
 processor.setFlag();

 }
}
</code></pre>

I'm reading about volatile keyword in Java and completely understand the theory part of it.

But, what I'm searching for is, a good case example, which shows what would happen if variable wasn't volatile and if it were.

Below code snippet doesn't work as expected (taken from <a href="https://stackoverflow.com/a/10764147/2546848">here</a>):

<pre><code>class Test extends Thread {

 boolean keepRunning = true;

 public void run() {
 while (keepRunning) {
 }

 System.out.println("Thread terminated.");
 }

 public static void main(String[] args) throws InterruptedException {
 Test t = new Test();
 t.start();
 Thread.sleep(1000);
 t.keepRunning = false;
 System.out.println("keepRunning set to false.");
 }
}
</code></pre>

Ideally, if <code>keepRunning</code> wasn't volatile, thread should keep on running indefinitely. But, it does stop after few seconds.

I've got two basic questions:

<ul>
<li>Can anyone explain volatile with example? Not with theory from JLS.</li>
<li>Is volatile substitute for synchronization? Does it achieve atomicity?</li>
</ul>

Simplest and understandable example of volatile keyword in Java

服务器

虚拟机

编译器

Java

我正在阅读Java中的volatile关键字，并且完全理解它的理论部分。但是，我正在寻找的是一个很好的例子，它展示了如果变量不是易失性的，以及如果变量是易失性的，会发生什么。下面的代码片段不能按预期工作(取自)：class Test extends Thread {    boolean keepRunning = t...

问Java中最简单易懂的volatile关键字示例
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中最简单易懂的volatile关键字示例EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中最简单易懂的volatile关键字示例
EN