volatile (computer programming)

<h2 id="in-c-and-c">In C and C++</h2>
In C and C++, volatile is a <a href="/facts/Type_qualifier/7tUPjsua">type qualifier</a>, like <a href="/facts/Const_(computer_programming)/Krve5QWn">const</a>, and is a part of a <a href="/facts/Data_type/fcx5hgVL">type</a> (e.g. the type of a variable or field). 
The behavior of the volatile keyword in C and C++ is sometimes given in terms of suppressing optimizations of an <a href="/facts/Optimizing_compiler/JXnv4LUd">optimizing compiler</a>: 1- don't remove existing volatile reads and writes, 2- don't add new volatile reads and writes, and 3- don't reorder volatile reads and writes. However, this definition is only an approximation for the benefit of new learners, and this approximate definition should not be relied upon to write real production code.
In C, and consequently C++, the volatile keyword was intended to:<a class="footnote-ref" id="fnref:1" href="#fn:1">1</a>

<ul><li>Allow access to <a href="/facts/Memory-mapped_I/O/PmLNFq01">memory-mapped I/O</a> devices.</li>
<li>Allow preserving values across a <a href="/facts/Setjmp/c9b2pNrL">longjmp</a>.</li>
<li>Allow sharing values between signal handlers and the rest of the program in volatile sig_atomic_t objects.</li></ul>
The C and C++ standards allow writing portable code that shares values across a <a href="/facts/Setjmp/c9b2pNrL">longjmp</a> in volatile objects, and the standards allow writing portable code that shares values between signal handlers and the rest of the code in volatile sig_atomic_t objects. Any other use of volatile keyword in C and C++ is inherently non-portable or incorrect. In particular, writing code with the volatile keyword for <a href="/facts/Memory-mapped_I/O/PmLNFq01">memory-mapped I/O</a> devices is inherently non-portable and always requires deep knowledge of the specific target C/C++ implementation and platform. 

<h3>Multi-Threading</h3>
It is a common misconception that the volatile keyword is useful in portable <a href="/facts/Thread_(computing)/hh8WHyPd">multi-threading</a> code in C and C++. The volatile keyword in C and C++ has never functioned as a useful, portable tool for any multi-threading scenario.<a class="footnote-ref" id="fnref:2" href="#fn:2">2</a><a class="footnote-ref" id="fnref:3" href="#fn:3">3</a><a class="footnote-ref" id="fnref:4" href="#fn:4">4</a><a class="footnote-ref" id="fnref:5" href="#fn:5">5</a> Unlike the <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a> and <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a> programming languages, operations on volatile variables in C and C++ are not <a href="/facts/Atomic_operation/u3pnNCvs">atomic</a>, and operations on volatile variables do not have sufficient memory ordering guarantees (i.e. <a href="/facts/Memory_barrier/am65f6bs">memory barriers</a>). Most C and C++ compilers, linkers, and runtimes simply do not provide the necessary memory ordering guarantees to make the volatile keyword useful for any multi-threading scenario. Before the C11 and C++11 standards, programmers were forced to rely on guarantees from the individual implementations and platforms (e.g. POSIX and WIN32) to write <a href="/facts/Thread_(computing)/hh8WHyPd">multi-threading</a> code. With the modern C11 and C++11 standards, programmers can write portable <a href="/facts/Thread_(computing)/hh8WHyPd">multi-threading</a> code using new portable constructs such as the std::atomic<T> templates.<a class="footnote-ref" id="fnref:6" href="#fn:6">6</a> 

<h3>Example of memory-mapped I/O in C</h3>
In this example, the code sets the value stored in foo to 0. It then starts to <a href="/facts/Polling_(computer_science)/WVa88JIg">poll</a> that value repeatedly until it changes to 255:

static int foo;

void bar(void) {
    foo = 0;

while (foo != 255)
         ;
}

An <a href="/facts/Optimizing_compiler/JXnv4LUd">optimizing compiler</a> will notice that no other code can possibly change the value stored in foo, and will assume that it will remain equal to 0 at all times. The compiler will therefore replace the function body with an <a href="/facts/Infinite_loop/NG4b7SFa">infinite loop</a> similar to this:

void bar_optimized(void) {
 foo = 0;

while (true)
         ;
}

However, the programmer may make foo refer to another element of the computer system such as a <a href="/facts/Hardware_register/V1roVh0p">hardware register</a> of a device connected to the <a href="/facts/CPU/Jxp1bqMV">CPU</a> which may change the value of foo while this code is running. (This example does not include the details on how to make foo refer to a hardware register of a device connected to the CPU.) Without the volatile keyword, an <a href="/facts/Optimizing_compiler/JXnv4LUd">optimizing compiler</a> will likely convert the code from the first sample with the read in the loop to the second sample without the read in the loop as part of the common <a href="/facts/Loop-invariant_code_motion/9jBNoTdm">loop-invariant code-motion optimization</a>, and thus the code will likely never notice the change that it is waiting for.
To prevent the compiler from doing this optimization, the volatile keyword can be used:

static volatile int foo;

void bar (void) {
    foo = 0;

while (foo != 255)
        ;
}

The volatile keyword prevents the compiler from moving the read out of the loop, and thus the code will notice the expected change to the variable foo.

<h3>Optimization comparison in C</h3>
The following C programs, and accompanying assembler language excerpts, demonstrate how the volatile keyword affects the compiler's output. The compiler in this case was <a href="/facts/GNU_Compiler_Collection/t07jh01k">GCC</a>.
While observing the assembly code, it is clearly visible that the code generated with volatile objects is more verbose, making it longer so the nature of volatile objects can be fulfilled. The volatile keyword prevents the compiler from performing optimization on code involving volatile objects, thus ensuring that each volatile variable assignment and read has a corresponding memory access. Without the volatile keyword, the compiler knows a variable does not need to be reread from memory at each use, because there should not be any writes to its memory location from any other thread or process.

<table><tbody><tr><th colspan="2">Assembly comparison</th></tr><tr><th>Without volatile keyword</th><th>With volatile keyword</th></tr><tr><td># include <stdio.h>int main() { /* These variables will never be created on stack*/ int a = 10, b = 100, c = 0, d = 0; /* "printf" will be called with arguments "%d" and 110 (the compiler computes the sum of a+b), hence no overhead of performing addition at run-time */ printf("%d", a + b); /* This code will be removed via optimization, but the impact of 'c' and 'd' becoming 100 can be seen while calling "printf" */ a = b; c = b; d = b; /* Compiler will generate code where printf is called with arguments "%d" and 200 */ printf("%d", c + d); return 0;}</td><td># include <stdio.h>int main() { volatile int a = 10, b = 100, c = 0, d = 0; printf("%d", a + b); a = b; c = b; d = b; printf("%d", c + d); return 0;}</td></tr><tr><th>gcc -S -O3 -masm=intel noVolatileVar.c -o without.s</th><th>gcc -S -O3 -masm=intel VolatileVar.c -o with.s</th></tr><tr><td> .file "noVolatileVar.c" .intel_syntax noprefix .section .rodata.str1.1,"aMS",@progbits,1.LC0: .string "%d" .section .text.startup,"ax",@progbits .p2align 4,,15 .globl main .type main, @functionmain:.LFB11: .cfi_startproc sub rsp, 8 .cfi_def_cfa_offset 16 mov esi, 110 mov edi, OFFSET FLAT:.LC0 xor eax, eax call printf mov esi, 200 mov edi, OFFSET FLAT:.LC0 xor eax, eax call printf xor eax, eax add rsp, 8 .cfi_def_cfa_offset 8 ret .cfi_endproc.LFE11: .size main, .-main .ident "GCC: (GNU) 4.8.2" .section .note.GNU-stack,"",@progbits</td><td> .file "VolatileVar.c" .intel_syntax noprefix .section .rodata.str1.1,"aMS",@progbits,1.LC0: .string "%d" .section .text.startup,"ax",@progbits .p2align 4,,15 .globl main .type main, @functionmain:.LFB11: .cfi_startproc sub rsp, 24 .cfi_def_cfa_offset 32 mov edi, OFFSET FLAT:.LC0 mov DWORD PTR [rsp], 10 mov DWORD PTR [rsp+4], 100 mov DWORD PTR [rsp+8], 0 mov DWORD PTR [rsp+12], 0 mov esi, DWORD PTR [rsp] mov eax, DWORD PTR [rsp+4] add esi, eax xor eax, eax call printf mov eax, DWORD PTR [rsp+4] mov edi, OFFSET FLAT:.LC0 mov DWORD PTR [rsp], eax mov eax, DWORD PTR [rsp+4] mov DWORD PTR [rsp+8], eax mov eax, DWORD PTR [rsp+4] mov DWORD PTR [rsp+12], eax mov esi, DWORD PTR [rsp+8] mov eax, DWORD PTR [rsp+12] add esi, eax xor eax, eax call printf xor eax, eax add rsp, 24 .cfi_def_cfa_offset 8 ret .cfi_endproc.LFE11: .size main, .-main .ident "GCC: (GNU) 4.8.2" .section .note.GNU-stack,"",@progbits</td></tr></tbody></table>
<h3>Standards Defects</h3>
While intended by both C and C++, the current C standard fails to express that the volatile semantics refer to the lvalue, not the referenced object. The respective defect report DR 476 (to C11) is still under review with <a href="/facts/C17_(C_standard_revision)/NGAWJzq6">C17</a>.<a class="footnote-ref" id="fnref:7" href="#fn:7">7</a>

<h3>Compiler Defects</h3>
Unlike other language features of C and C++, the volatile keyword is not well supported by most C/C++ implementations - even for portable uses according to the C and C++ standards. Most C/C++ implementations are buggy regarding the behavior of the volatile keyword.<a class="footnote-ref" id="fnref:8" href="#fn:8">8</a><a class="footnote-ref" id="fnref:9" href="#fn:9">9</a> Programmers should take great care whenever using the volatile keyword in C and C++.

<h2 id="in-java">In Java</h2>
In all modern versions of the <a href="/facts/Java_programming_language/9ScgFyAL">Java programming language</a>, the volatile keyword gives the following guarantees:

<ul><li>volatile reads and writes are <a href="/facts/Atomic_operation/u3pnNCvs">atomic</a>. In particular, reads and writes to long and double fields will not tear. (The <a href="/facts/Atomic_operation/u3pnNCvs">atomic</a> guarantee applies only to the volatile primitive value or the volatile reference value, and not to any Object value.)</li>
<li>There is a single global ordering of all volatile reads and writes. In other words, a volatile read will read the current value (and not a past or future value), and all volatile reads will agree on a single global order of volatile writes.</li>
<li>volatile reads and writes have "acquire" and "release" <a href="/facts/Memory_barrier/am65f6bs">memory barrier</a> semantics (known in the Java standard as <a href="/facts/Happened-before/I3oA64q3">happens-before</a>).<a class="footnote-ref" id="fnref:10" href="#fn:10">10</a><a class="footnote-ref" id="fnref:11" href="#fn:11">11</a> In other words, volatile provides guarantees about the relative order of volatile and non-volatile reads and writes. In other words, volatile basically provides the same memory visibility guarantees as a Java <a href="/facts/Lock_(computer_science)/e3a9gnJT">synchronized block</a> (but without the mutual exclusion guarantees of a <a href="/facts/Lock_(computer_science)/e3a9gnJT">synchronized block</a>).</li></ul>
Together, these guarantees make volatile into a useful <a href="/facts/Thread_(computing)/hh8WHyPd">multi-threading</a> construct in <a href="/facts/Java_programming_language/9ScgFyAL">Java</a>. In particular, the typical <a href="/facts/Double-checked_locking/VftRmHXu">double-checked locking</a> algorithm with volatile works correctly in <a href="/facts/Java_programming_language/9ScgFyAL">Java</a>.<a class="footnote-ref" id="fnref:12" href="#fn:12">12</a> 

<h3>Early Versions Of Java</h3>
Before Java version 5, the Java standard did not guarantee the relative ordering of volatile and non-volatile reads and writes. In other words, volatile did not have "acquire" and "release" <a href="/facts/Memory_barrier/am65f6bs">memory barrier</a> semantics. This greatly limited its use as a <a href="/facts/Thread_(computing)/hh8WHyPd">multi-threading</a> construct. In particular, the typical <a href="/facts/Double-checked_locking/VftRmHXu">double-checked locking</a> algorithm with volatile did not work correctly.

<h2 id="in-c">In C#</h2>
In <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>, volatile ensures that code accessing the field is not subject to some thread-unsafe optimizations that may be performed by the compiler, the CLR, or by hardware. When a field is marked volatile, the compiler is instructed to generate a "memory barrier" or "fence" around it, which prevents instruction reordering or caching tied to the field. When reading a volatile field, the compiler generates an acquire-fence, which prevents other reads and writes to the field from being moved before the fence. When writing to a volatile field, the compiler generates a release-fence; this fence prevents other reads and writes to the field from being moved after the fence.<a class="footnote-ref" id="fnref:13" href="#fn:13">13</a>
Only the following types can be marked volatile: all reference types, Single, Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Char, and all enumerated types with an underlying type of Byte, SByte, Int16, UInt16, Int32, or UInt32.<a class="footnote-ref" id="fnref:14" href="#fn:14">14</a> (This excludes value <a href="/facts/Struct/1fvSgenB">structs</a>, as well as the primitive types Double, Int64, UInt64 and Decimal.)
Using the volatile keyword does not support fields that are <a href="/facts/Evaluation_strategy/Pc9kLWgs">passed by reference</a> or <a href="/facts/Closure_(computer_programming)/droP22Xn">captured local variables</a>; in these cases, Thread.VolatileRead and Thread.VolatileWrite must be used instead.<a class="footnote-ref" id="fnref:15" href="#fn:15">15</a>
In effect, these methods disable some optimizations usually performed by the C# compiler, the JIT compiler, or the CPU itself. The guarantees provided by Thread.VolatileRead and Thread.VolatileWrite are a superset of the guarantees provided by the volatile keyword: instead of generating a "half fence" (ie an acquire-fence only prevents instruction reordering and caching that comes before it), VolatileRead and VolatileWrite generate a "full fence" which prevent instruction reordering and caching of that field in both directions.<a class="footnote-ref" id="fnref:16" href="#fn:16">16</a> These methods work as follows:<a class="footnote-ref" id="fnref:17" href="#fn:17">17</a>

<ul><li>The Thread.VolatileWrite method forces the value in the field to be written to at the point of the call. In addition, any earlier program-order loads and stores must occur before the call to VolatileWrite and any later program-order loads and stores must occur after the call.</li>
<li>The Thread.VolatileRead method forces the value in the field to be read from at the point of the call. In addition, any earlier program-order loads and stores must occur before the call to VolatileRead and any later program-order loads and stores must occur after the call.</li></ul>
The Thread.VolatileRead and Thread.VolatileWrite methods generate a full fence by calling the Thread.MemoryBarrier method, which constructs a memory barrier that works in both directions. In addition to the motivations for using a full fence given above, one potential problem with the volatile keyword that is solved by using a full fence generated by Thread.MemoryBarrier is as follows: due to the asymmetric nature of half fences, a volatile field with a write instruction followed by a read instruction may still have the execution order swapped by the compiler. Because full fences are symmetric, this is not a problem when using Thread.MemoryBarrier.<a class="footnote-ref" id="fnref:18" href="#fn:18">18</a>

<h2 id="in-fortran">In Fortran</h2>
VOLATILE is part of the <a href="/facts/Fortran/m1KqjcMU">Fortran 2003</a> standard,<a class="footnote-ref" id="fnref:19" href="#fn:19">19</a> although earlier version supported it as an extension. Making all variables volatile in a function is also useful finding <a href="/facts/Aliasing_(computing)/C7wT3dQy">aliasing</a> related bugs.

integer, volatile :: i ! When not defined volatile the following two lines of code are identical
write(*,*) i**2 ! Loads the variable i once from memory and multiplies that value times itself
write(*,*) i*i ! Loads the variable i twice from memory and multiplies those values

By always "drilling down" to memory of a VOLATILE, the Fortran compiler is precluded from reordering reads or writes to volatiles. This makes visible to other threads actions done in this thread, and vice versa.<a class="footnote-ref" id="fnref:20" href="#fn:20">20</a>
Use of VOLATILE reduces and can even prevent optimization.<a class="footnote-ref" id="fnref:21" href="#fn:21">21</a>

<h2 id="external-links">External links</h2>
<ul><li><a href="http://www.adaic.com/standards/05rm/html/RM-C-6.html">Ada Reference Manual C.6: Shared Variable Control</a></li>
<li><a href="https://web.archive.org/web/20160304053622/https://www.kernel.org/doc/Documentation/volatile-considered-harmful.txt">Linux kernel: volatile-considered-harmful</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1">"Publication on C++ standards committee". <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2016.html" target="_blank">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2016.html</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></li>
<li id="fn:2">"Volatile Keyword In Visual C++". Microsoft MSDN. 21 September 2021. <a href="http://msdn2.microsoft.com/en-us/library/12a04hfd.aspx" target="_blank">http://msdn2.microsoft.com/en-us/library/12a04hfd.aspx</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></li>
<li id="fn:3">"Linux Kernel Documentation – Why the "volatile" type class should not be used". kernel.org. <a href="https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html" target="_blank">https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></li>
<li id="fn:4">Scott Meyers; Andrei Alexandrescu (2004). "C++ and the Perils of Double-Checked Locking" (PDF). DDJ. <a href="http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf" target="_blank">http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></li>
<li id="fn:5">Jeremy Andrews (2007). "Linux: Volatile Superstition". kerneltrap.org. Archived from the original on 2010-06-20. Retrieved Jan 9, 2011. <a href="https://web.archive.org/web/20100620121940/http://kerneltrap.org/Linux/Volatile_Superstition" target="_blank">https://web.archive.org/web/20100620121940/http://kerneltrap.org/Linux/Volatile_Superstition</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></li>
<li id="fn:6">"volatile (C++)". Microsoft MSDN. 21 September 2021. <a href="https://msdn.microsoft.com/en-us/library/12a04hfd.aspx" target="_blank">https://msdn.microsoft.com/en-us/library/12a04hfd.aspx</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></li>
<li id="fn:7">Clarification Request Summary for C11. Version 1.13, October 2017. <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2244.htm" target="_blank">http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2244.htm</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></li>
<li id="fn:8">Eide, Eric; Regehr, John (October 2008). "Volatiles Are Miscompiled, and What to Do about It" (PDF). Proceedings of the Eighth ACM and IEEE International Conference on Embedded Software (EMSOFT), Atlanta, Georgia, USA – via cs.utah.edu. <a href="https://users.cs.utah.edu/~regehr/papers/emsoft08-preprint.pdf" target="_blank">https://users.cs.utah.edu/~regehr/papers/emsoft08-preprint.pdf</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></li>
<li id="fn:9">"Volatile Bugs, Three Years Later – Embedded in Academia". blog.regehr.org. Retrieved 2024-08-28. <a href="https://blog.regehr.org/archives/503" target="_blank">https://blog.regehr.org/archives/503</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></li>
<li id="fn:10">Section 17.4.4: Synchronization Order
"The Java® Language Specification, Java SE 7 Edition". Oracle Corporation. 2013. Retrieved 2013-05-12. <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.4.4" target="_blank">http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.4.4</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></li>
<li id="fn:11">"Java Concurrency: Understanding the 'Volatile' Keyword". dzone.com. 2021-03-08. Archived from the original on 2021-05-09. Retrieved 2021-05-09. <a href="https://web.archive.org/web/20210509104459/https://dzone.com/articles/java-concurrency-understanding-the-volatile-keyword" target="_blank">https://web.archive.org/web/20210509104459/https://dzone.com/articles/java-concurrency-understanding-the-volatile-keyword</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></li>
<li id="fn:12">Neil Coffey. "Double-checked Locking (DCL) and how to fix it". Javamex. Retrieved 2009-09-19. <a href="http://www.javamex.com/tutorials/double_checked_locking_fixing.shtml" target="_blank">http://www.javamex.com/tutorials/double_checked_locking_fixing.shtml</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></li>
<li id="fn:13">Albahari, Joseph. "Part 4: Advanced Threading". Threading in C#. O'Reilly Media. Archived from the original on 12 December 2019. Retrieved 9 December 2019.{{cite web}}: CS1 maint: bot: original URL status unknown (link) <a href="https://web.archive.org/web/20191212032535/http://www.albahari.com/threading/part4.aspx#_Nonblocking_Synchronization" target="_blank">https://web.archive.org/web/20191212032535/http://www.albahari.com/threading/part4.aspx#_Nonblocking_Synchronization</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></li>
<li id="fn:14">Richter, Jeffrey (February 11, 2010). "Chapter 7: Constants and Fields". CLR Via C#. Microsoft Press. pp. 183. ISBN 978-0-7356-2704-8. <a href="978-0-7356-2704-8" target="_blank">978-0-7356-2704-8</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></li>
<li id="fn:15">Albahari, Joseph. "Part 4: Advanced Threading". Threading in C#. O'Reilly Media. Archived from the original on 12 December 2019. Retrieved 9 December 2019.{{cite web}}: CS1 maint: bot: original URL status unknown (link) <a href="https://web.archive.org/web/20191212032535/http://www.albahari.com/threading/part4.aspx#_Nonblocking_Synchronization" target="_blank">https://web.archive.org/web/20191212032535/http://www.albahari.com/threading/part4.aspx#_Nonblocking_Synchronization</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></li>
<li id="fn:16">Albahari, Joseph. "Part 4: Advanced Threading". Threading in C#. O'Reilly Media. Archived from the original on 12 December 2019. Retrieved 9 December 2019.{{cite web}}: CS1 maint: bot: original URL status unknown (link) <a href="https://web.archive.org/web/20191212032535/http://www.albahari.com/threading/part4.aspx#_Nonblocking_Synchronization" target="_blank">https://web.archive.org/web/20191212032535/http://www.albahari.com/threading/part4.aspx#_Nonblocking_Synchronization</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></li>
<li id="fn:17">Richter, Jeffrey (February 11, 2010). "Chapter 28: Primitive Thread Synchronization Constructs". CLR Via C#. Microsoft Press. pp. 797–803. ISBN 978-0-7356-2704-8. <a href="978-0-7356-2704-8" target="_blank">978-0-7356-2704-8</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></li>
<li id="fn:18">Albahari, Joseph. "Part 4: Advanced Threading". Threading in C#. O'Reilly Media. Archived from the original on 12 December 2019. Retrieved 9 December 2019.{{cite web}}: CS1 maint: bot: original URL status unknown (link) <a href="https://web.archive.org/web/20191212032535/http://www.albahari.com/threading/part4.aspx#_Nonblocking_Synchronization" target="_blank">https://web.archive.org/web/20191212032535/http://www.albahari.com/threading/part4.aspx#_Nonblocking_Synchronization</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></li>
<li id="fn:19">"VOLATILE Attribute and Statement". Cray. Archived from the original on 2018-01-23. Retrieved 2016-04-22. <a href="https://web.archive.org/web/20180123165050/http://docs.cray.com/books/S-3692-51/html-S-3692-51/zfixedn3c8sk4c.html" target="_blank">https://web.archive.org/web/20180123165050/http://docs.cray.com/books/S-3692-51/html-S-3692-51/zfixedn3c8sk4c.html</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></li>
<li id="fn:20">"Volatile and shared array in Fortran". Intel.com. <a href="https://software.intel.com/en-us/forums/intel-moderncode-for-parallel-architectures/topic/279191" target="_blank">https://software.intel.com/en-us/forums/intel-moderncode-for-parallel-architectures/topic/279191</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></li>
<li id="fn:21">"VOLATILE". Oracle.com. <a href="https://docs.oracle.com/cd/E19957-01/805-4939/6j4m0vnbq/index.html" target="_blank">https://docs.oracle.com/cd/E19957-01/805-4939/6j4m0vnbq/index.html</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></li>
</ol>

volatile (computer programming) open-in-new

volatile (computer programming)