What is Volatile means in Java

Volatile guarantees this in Java:

1) There is a global ordering on the reads and writes to a volatile variable. This implies that every thread accessing a volatile field will read its current value before continuing, instead of (potentially) using a cached value. (However, there is no guarantee about the relative ordering of volatile reads and writes with regular reads and writes, meaning that it's generally not a useful threading construct.)
2)  After java 5, Volatile reads and writes establish a happens-before relationship, much like acquiring and releasing a mutex.

Using volatile may be faster than a lock, but it will not work in some situations.The range of situations in which volatile is effective was expanded in Java 5; in particular, double-checked locking now works correctly.

Where to use Volatile :

Best case will be where where the variable updates should be visible to all threads because The value of this variable will never be cached thread-locally: all reads and writes will go straight to "main memory". and Access to the variable acts as though it is enclosed in a synchronized block, synchronized on itself.

Danger of Volatile:

Atomic operations are not thread safe with volatile variables. see this Code :

volatile int i;

.

..

i += 5;

Here i += 5 is not thread safe and  this is equivalent to

int temp;

synchronized (i) {

  temp = i;

}

temp += 5;

synchronized (i) {

  i = temp;

}

Solution of this in Java 5: Java Atomic package

Java Atomic package works on principle of CAS (compare and swap). The signature of any CAS method is -

   boolean compareAndSet(expectedValue, updateValue);

As Described in Java Doc:

"This method (which varies in argument types across different classes) atomically sets a variable to the updateValue if it currently holds the expectedValue, reporting true on success. The classes in this package also contain methods to get and unconditionally set values, as well as a weaker conditional atomic update operation weakCompareAndSet described below.

The specifications of these methods enable implementations to employ efficient machine-level atomic instructions that are available on contemporary processors. However on some platforms, support may entail some form of internal locking. Thus the methods are not strictly guaranteed to be non-blocking -- a thread may block transiently before performing the operation."

Instances of classes AtomicBoolean, AtomicInteger, AtomicLong, and AtomicReference each provide access and updates to a single variable of the corresponding type. Each class also provides appropriate utility methods for that type.

Example of Increment method in Atomic class :

class Sequencer {

   private final AtomicLong sequenceNumber

     = new AtomicLong(0);

   public long next() {

     return sequenceNumber.getAndIncrement();

   }

 }