Understanding volatile keyword in java in details

What is Atomic ? The term atomic is related to the atom, once considered the smallest possible unit. When computer code is considered atomic it can not be interrupted during its execution, We can also define atomic code as code that can’t be found in an intermediate state.

Atomicity in Java - Java specifies that basic loading and storing of variable is the atomic. That means the value of the variable can’t be found in a interim state during the store not be changed in the middle of loading the variable to a register.

Java Memory Model – Unfortunately , java’s memory model is a bit more complex. Threads are allowed to hold the values of variable in local memory. In that case, when one thread changes the values of the variable, another thread may not see the changed value. This is particularly in loops where looping is controlled by a variable. The lopping may be have already loaded the value of the variable into the register and does not necessary notice when another thread changes the vales.

Solution 1 – One way to solve this problem is to provider setter/getter for the variable and make then synchronize using synchronized keyword in declaration. This will work because while getting lock all temporary values stored in register will get cleared. But this will be little complex solution when one easy and elegant solution is available.

volatile variable – The more elegant solution for this problem is volatile variable. If a variable is marked as volatile, every time variable is used it must be read from main memory. Similarly when every time variable is written it must be stored directly to memory.

When not to use volatile ? – This solution is feasible only when you don’t have any code in getter/setter methods which again uses/modify the variable value. Form example increment/decrement operation can not be synchronized using volatile variable. These operations are not atomic as it is as series of operation like retrieve-modify-store.

Reference: Book – Java Threads , Third Edition

Comments

  1. AnonymousMarch 29, 2010 at 3:06 AM

    This is very true particularly when there is a threaded application running on a multi-core cpu. volatile ensures all the local copies of the variable is in synch.

    ReplyDelete
  2. Javin PaulMarch 11, 2011 at 9:19 PM

    Nice artielce , by the way just to add from my experience I think we should make a variable volatile when we want ensure that thread doesn' cache the value of variable ,e.g. in below code
    while(!stop) {
    doWork() ;
    }

    Thread can cache the value of "stop" instead of getting it from main memory every time and if in between any other thread changes the value , it would not be visible to this thread. making boolean variable "stop" as volatile ensures this will not happen.

    Thanks
    Javin
    How to avoid deadlock in Java code

    ReplyDelete

Post a Comment

Popular posts from this blog

State Design Pattern by Example

Image
State pattern falls under the category of Behavioral patterns. State design pattern comes in picture when a system’s behavior is depends on its own state or some other resource’s state. If an implementation is depends on the states, we end up with snarl of conditional statement every where in code. A very neat approach to deal with such situation is to separate out every state’s behavior and use them where ever they are applicable. The state pattern allows an object to alter its behavior when is internal state changes . The object is appeared to change its class. State pattern is a way to implement the same. Class Diagram : As above class diagram shows, System class holds state instance. As state of system changes , all handle request delegated to respective State’s concrete implementation. Example : Have an example of Vending machine. Vending machine has following states No Coin Inserted Coin Inserted Dispensing Empty Following diagram explain behavior
Read more

Eclipse command framework core expression: Property tester

Image
Addition to Eclipse command framework series, this post explains use of property tester to control command’s enable/visible properties. In earlier post we have tried declarative way to achieve same thing but property tester gives us more control. Property tester is associated with, tester class which implements PropertyTester.java, a namespace and set of property which it supports. We can refer this property tester using its namespace + a property name. It gives you call back to test() method with property name as parameter inside property tester class. We can configure property tester for type of input parameter. Here is sample declaration of property tester extension point < extension point ="org.eclipse.core.expressions.propertyTesters" > < propertyTester class ="com.example.advance.cmd.EditorTester" id ="com.example.advance.cmd.propertyTester1" namespace ="com.example.advance.cm
Read more

Composite Design Pattern by example

Image
This post explains Composite design pattern with an example. When to use ? – Use Composite pattern when you have treat a collection of objects as they were once one thing. With Composite design pattern it is very easy to simplify operations over collection data structure. It reduces complexity of the code required if you were going to handle collection as special case. How to Use? - The Composite pattern consist of Component, Leaf and Composite Classes as shown below class diagram Component – Component declares the common interface that both the single and composite nodes will implements Leaf – The leaf class represent the singular atomic data type implementing he component interface.     Composite – Composite is an abstract entity which declares common functionality which are needed by concrete implementation for handling collection data. An Example -   Item.java public interface Item {     public double getPrice(); }   ColdDrink.java pu
Read more