Volatile variable in Java

by

Declaring a volatile Java variable means:

  • The value of this variable will never be cached thread-locally: all reads and writes will go straight to “main memory”.
  • Access to the variable acts as though it is enclosed in a synchronized block, synchronized on itself.

Just for your reference, When is volatile needed ?

When multiple threads using the same
variable, each thread will have its
own copy of the local cache for that
variable. So, when it’s updating the
value, it is actually updated in the
local cache not in the main variable
memory. The other thread which is
using the same variable doesn’t know
anything about the values changed by
the another thread. To avoid this
problem, if you declare a variable as
volatile, then it will not be stored
in the local cache. Whenever thread
are updating the values, it is updated
to the main memory. So, other threads
can access the updated value.

From JLS §17.4.7 Well-Formed Executions

We only consider well-formed
executions. An execution E = < P, A,
po, so, W, V, sw, hb > is well formed
if the following conditions are true:

  1. Each read sees a write to the same
    variable in the execution. All reads
    and writes of volatile variables are
    volatile actions. For all reads r in
    A, we have W(r) in A and W(r).v = r.v.
    The variable r.v is volatile if and
    only if r is a volatile read, and the
    variable w.v is volatile if and only
    if w is a volatile write.

  2. Happens-before order is a partial
    order. Happens-before order is given
    by the transitive closure of
    synchronizes-with edges and program
    order. It must be a valid partial
    order: reflexive, transitive and
    antisymmetric.

  3. The execution obeys
    intra-thread consistency. For each
    thread t, the actions performed by t
    in A are the same as would be
    generated by that thread in
    program-order in isolation, with each
    write wwriting the value V(w), given
    that each read r sees the value
    V(W(r)). Values seen by each read are
    determined by the memory model. The
    program order given must reflect the
    program order in which the actions
    would be performed according to the
    intra-thread semantics of P.

  4. The execution is happens-before consistent
    (§17.4.6).

  5. The execution obeys
    synchronization-order consistency. For
    all volatile reads r in A, it is not
    the case that either so(r, W(r)) or
    that there exists a write win A such
    that w.v = r.v and so(W(r), w) and
    so(w, r).

Useful Link : What do we really know about non-blocking concurrency in Java?

More Related Contents:

  1. Volatile vs Static in Java
  2. Simplest and understandable example of volatile keyword in Java
  3. Why doesn’t volatile in java 5+ ensure visibility from another thread?
  4. What is the volatile keyword useful for?
  5. What’s the difference between Thread start() and Runnable run()
  6. Difference between volatile and synchronized in Java
  7. Why must wait() always be in synchronized block
  8. ExecutorService that interrupts tasks after a timeout
  9. Volatile boolean vs AtomicBoolean
  10. When would you call java’s thread.run() instead of thread.start()?
  11. What are the main uses of yield(), and how does it differ from join() and interrupt()?
  12. What are the advantages of using an ExecutorService?
  13. What is the JVM thread scheduling algorithm?
  14. Why does Thread.isInterrupted () always return false?
  15. Impossible to make a cached thread pool with a size limit?
  16. When should I use a CompletionService over an ExecutorService?
  17. How does `this` reference to an outer class escape through publishing inner class instance?
  18. Are non-synchronised static methods thread safe if they don’t modify static class variables?
  19. Forcing multiple threads to use multiple CPUs when they are available
  20. ThreadPoolExecutor Block When Queue Is Full?
  21. Java ExecutorService: awaitTermination of all recursively created tasks
  22. Why does Java not see the updated value from another thread?
  23. What is adaptive spinning w.r.t lock acquisition?
  24. Which concurrent Queue implementation should I use in Java?
  25. Jboss Java EE container and an ExecutorService
  26. Thread Confinement
  27. How can I wrap a method so that I can kill its execution if it exceeds a specified timeout?
  28. Java, divide incoming work uniformly via hashing in multithreaded evnironments
  29. notifyAll() throws IllegalMonitorStateException
  30. Will a chain of method calls (CompletableFuture API) execute asynchronously if the first method in a chain is asynchronous?

Leave a Comment