Java defines two interesting type modifiers: transient and volatile. These modifiers are used to handle somewhat specialized situations.

When an instance variable is declared as transient, then its value need not persist when an object is stored. For example:

class T {

transient int a; // will not persist

int b; // will persist

}

Here, if an object of type T is written to a persistent storage area, the contents of a would not be saved, but the contents of b would. The volatile modifier tells the compiler that the variable modified by volatile can be changed unexpectedly by other parts of your program. One of these situations involves multithreaded programs.  In a multithreaded program, sometimes, two or more threads share the same instance variable. For efficiency considerations, each thread can keep its own, private copy of such a shared variable. The real (or master) copy of the variable is updated at various times, such as when a synchronized method is entered. While this approach works fine, it may be inefficient at times. In some cases, all that really matters is that the master copy of a variable always reflects its current state. To ensure this, simply specify the variable as volatile, which tells the compiler that it must always use the master copy of a volatile variable (or, at least, always keep any private copies up to date with the master copy, and vice versa). Also, accesses to the master variable must be executed in the precise order in which they are executed on any private copy.

Note: volatile in Java has, more or less, the same meaning that it has in C/C++.

2007-09-10

Comments(15)

1.	Your explanation is good and okay but, it will be better or most lovely only if you can try to and some real java program code to illustrate what you are talking about better. By: Emmanuel at 2009-05-28 02:45:11
2.	Your explanation is perfectly clear and not in need of "illustrative examples"! In particular, it succinctly makes clear that one should ALWAYS decorate an instance variable that is to be shared with "volatile". By: Percy at 2009-06-08 14:14:39
3.	Hi thanks for your information. I got simple solution for my breath taking problem. I am programming using java communication API with Serial port. There data is recieved very fastly.Each time we have to get data in multi threading. It is very tedious to get all information sometimes. Solution: By using my variable with volatile i have fixed my problem.And my application is running with 100%. By: karthikeyan at 2009-09-18 04:50:37
4.	Hello, A volatile variable does not have a copy maintained in the local memory of the thread (on the stack). All changes to the volatile variable (caused by multiple threads) are flushed out to the heap memory (visible from all threads). Hence volatile variable values remain consistent for all threads. On the other hand, for other instance variables, each java thread maintains a local copy on the stack. Multiple threads may modify this local copy of the instance variable and hence inconsistent values may be visible for multiple threads. For preventing this condition, we synchronize. During synchronization, a lock is first taken on the object monitor. Then the thread reads the state from the main memory and flushes its internal state. Subsequently, the synchronized code block/method code is executed. Once the execution completes, all the changes to the variables of that thread are flushed out to the main memory. Then the object monitor lock is released. So, as we can see, volatile is a specialized case of synchronization. The only exceptions are, that it operates on a single field and no locks on the object monitor are required (as it operates on the heap memory and not the thread local stack memory). By: aayush at 2009-11-16 07:38:23
5.	If you are working with the multi-threaded programming, the volatile keyword will be more useful. 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. package javabeat.samples; class ExampleThread extends Thread { private volatile int testValue; public ExampleThread(String str){ super(str); } public void run() { for (int i = 0; i < 3; i++) { try { System.out.println(getName() + " : "+i); if (getName().equals("Thread 1 ")) { testValue = 10; } if (getName().equals("Thread 2 ")) { System.out.println( "Test Value : " + testValue); } Thread.sleep(1000); } catch (InterruptedException exception) { exception.printStackTrace(); } } } } public class VolatileExample { public static void main(String args[]) { new ExampleThread("Thread 1 ").start(); new ExampleThread("Thread 2 ").start(); } } By: Prithvi at 2010-01-07 10:24:12
6.	You should consider using different threads that are not instantiated from the same class, but different classes. The volatile keyword does not work. The only workaround is to use another moitor class. I will try to sync and see if thqat will help. By: Jeremy at 2010-01-13 23:02:11
7.	If you are working with the multi-threaded programming, the volatile keyword will be more useful. 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. package javabeat.samples; class ExampleThread extends Thread { private volatile int testValue; public ExampleThread(String str){ super(str); } public void run() { for (int i = 0; i < 3; i++) { try { System.out.println(getName() + " : "+i); if (getName().equals("Thread 1 ")) { testValue = 10; } if (getName().equals("Thread 2 ")) { System.out.println( "Test Value : " + testValue); } Thread.sleep(1000); } catch (InterruptedException exception) { exception.printStackTrace(); } } } } public class VolatileExample { public static void main(String args[]) { new ExampleThread("Thread 1 ").start(); new ExampleThread("Thread 2 ").start(); } } Not Working i tried it... but ---------- run java ---------- Thread 1 : 0 Thread 2 : 0 Test Value : 0 Thread 2 : 1 Test Value : 0 Thread 1 : 1 Thread 1 : 2 Thread 2 : 2 Test Value : 0 Output completed (3 sec consumed) it career By: it career at 2010-02-24 00:13:50
8.	Your explanation is good but, it will be better if you can try explain with some real java program code. By: Jabaraj at 2010-03-22 06:02:33
9.	This is an excerpt from Java Complete Reference.Just copy and paste technology By: Guest at 2010-03-25 01:36:57
10.	Explanation is very good. Thanks all. By: reddy at 2010-04-07 08:47:09
11.	The example is wrong, because there are two seperate instances of ExampleThread, so the testValue is not shared by the threads By: billGates at 2010-07-06 16:56:13
12.	This example is working fine....I think BillGates has misunderstood somewhere.. By: Monoj Rath at 2010-07-15 01:27:51
13.	HI your explanation is absolutely correct but I am sure that it's copied from Complete reference Java2 fifth edition of Herbert Schildt. By: Anil R. Chinchawade at 2010-07-28 02:02:01
14.	Hi ,learn a new thing about These Transient and Volatile Modifiers . Thanks to all of you. By: LakshmiNarayana Golla at 2010-07-28 02:49:48
15.	Can some body throw more light on TRANSIENT .... By: Anish at 2010-08-03 07:30:58

Your name (required):


Your email(required, will not be shown to the public):


Your sites URL (optional):


Your comments:

Enter Code: