Almost every application reads and writes data to the main memory of the computer. For performance reasons, these operations aren't performed directly in the memory. CPUs have a system of cache memory, so applications write data in the cache and then the data is moved from the cache to the main memory.

In multithread applications, concurrent threads run in different CPUs or cores inside a CPU. When a thread modifies a variable stored in the memory, the modification is made in the cache or the CPU or core where it's running. However, there's no guarantee about when that modification would reach the main memory. If another thread wants to read the value of the data, it's possible that it would not read the modified value because it's not in the main memory of the computer.

To solve this problem (there are other solutions, such as the synchronized keyword), the Java language includes the volatile keyword. It's a modifier that allows you to specify that a variable must always be read from and stored in the main memory, not the cache of your CPU. You should use the volatile keyword when it's important that other threads have visibility of the actual value of the variable; however, order of access to that variable is not important. In this scenario, the volatile keyword will give you better performance because it doesn't need to get any monitor or lock to access the variable. On the contrary, if the order of access to the variable is important, you must use another synchronization mechanism.

In this recipe, you will learn how to use the volatile keyword and the effects of its use.