Skip to main content

Volatile and Synchronized in Java

Volatile is just another modifier like private , protected etc. It modifies the visibility of the variables and is generally more relevant in thread context.
Volatile when used on a variable ensures that every thread that is using it has the latest copy. It is important in multi threaded programming that shared variables which are frequently read and write by the threads are marked as volatile.
JVM is free to do anything with the variables and every thread can, actually does keep its own copy of variable meaning if a thread writes a new value to a variable, the other thread won't get that latest value.

private int x  = 5;

Thread 1 uses it and makes it 8, but thread 2 will have its own copy as 5 and won't see new value 8.
This can of course leads to a lot of problems and I don't think there is any need to explain that.
Primary three reasons to use volatile when needed:

1. Every thread keeps it own copy of a variable, so if you want a shared variable with publish sort of functionality i.e. that every where its latest value is used, make it volatile.
2. CPU caches : if the variable is cached it isn't necessary that that value will be updated which could lead some odd values with some threads. Hence volatile.
3. Volatile ensures that all the operations happening on that variable are atomic. For eg changing a Long value is actually two write operations than one. If that variable is not volatile it might happen that when one thread was in middle of process of modifying that variable , some other thread accessed it and got some arbitrary value since write operation was not complete.

The volatile keyword ensures that before any other thread reads that value, the write operations are completed.
Synchronized is used to achieve locks on variables which are supposed to be accessed by the different threads. Where volatile ensures every thread has the latest value, it fails to maintain the write operation or perhaps the sequence of write operations done on  a variable. This is where synchronized comes into play.
Synchronized should be implemented properly. Instead of making whole class synchronized , the actual data structures should be identified which needs to be synchronized and should be synchronized. However in some cases when that data structure is in use everywhere avoiding synchronizing every class methods is the only option.


Popular posts from this blog

Guide : Spring Boot with Apache CXF for REST services

In this series of guide, we are going to explore writing REST services with Apache CXF using Spring Boot. The project is build using maven. I assume that you already know how to use maven. Step 1 : Adding dependencies for Spring Boot By default you have to inherit the parent pom of spring boot, but that cannot be followed everytime, so I use an alternative to that. I basically add spring boot pom as dependency so that it brings all the dependencies. <properties> <>UTF-8</> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> <spring.version>1.4.3.RELEASE</spring.version> <cxf.version>3.1.10</cxf.version> </properties> <dependencies> <dependency> <!-- Alternative to inheriting from parent spring pom --> <groupId>org.springframework.boot&l

Enabling CXF goodies in Spring Boot

In this post we are going to add some of the CXF features to our existing app that we developed in  previous post . These features are : ID Logging Jackson Provider for POJO to JSON conversion Swagger 2 documentation Step 1: Configuration class Create a RestServer class in config package as shown below package org . blog . config ; import com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider ; import org.apache.cxf.feature.LoggingFeature ; import org.apache.cxf.jaxrs.swagger.Swagger2Feature ; import org.springframework.context.annotation.Bean ; import org.springframework.context.annotation.Configuration ; /** * Created by Anand_Rajneesh on 3/23/2017. */ @Configuration public class RestServer { @Bean public JacksonJsonProvider jsonProvider (){ return new JacksonJsonProvider (); } @Bean public LoggingFeature loggingFeature (){ return new LoggingFeature (); } @Bean public Swagger2Featur

Power of declarative syntax of Lambda

Since Java has introduced lambda, writing code has become a breeze especially when it comes to expressing what you want to computer to do rather than how to do it. The following is a question from Project Euler and is solved using lambdas in Java8. Let d( n ) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n ). If d( a ) = b and d( b ) = a , where a ≠ b , then a and b are an amicable pair and each of a and b are called amicable numbers. For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220. Evaluate the sum of all the amicable numbers under 10000.  A simple brute force solution is to check every number from 2 to 10000 and if its  an amicable number then add it to sum. Listing it in steps you are basically doing 3 things: Take numbers from 2 to 10000 If number is amicable Add it In Java 7 one will