Java transient关键字

Volatile修饰的成员变量在每次被线程访问时，都强迫从主内存中重读该成员变量的值。并且，当成员变量发生变化时，强迫线程将变化值回写到主内存。这样在任什么时候刻，两个不一样的线程老是看到某个成员变量的同一个值。   
Java语言规范中指出：为了得到最佳速度，容许线程保存共享成员变量的私有拷贝，并且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。   
这样当多个线程同时与某个对象交互时，就必需要注意到要让线程及时的获得共享成员变量的变化。   

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。   

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，没必要使用。   

因为使用volatile屏蔽掉了VM中必要的代码优化，因此在效率上比较低，所以必定在必要时才使用此关键字。   
  
java关键字Transient   

转自http://horst.sun.blog.163.com/blog/static/348849612007614494492/   

翻译自http://www.devx.com/tips/Tip/13726。   

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，咱们不想   
用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，能够在这个域前加上关键字transient。   
transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。  
注意static变量也是能够串行化的 
  
首先，让咱们看一些Java serialization的代码：   

public class LoggingInfo implements java.io.Serializable   
{   
    private Date loggingDate = new Date();   
    private String uid;   
    private transient String pwd;   
      
    LoggingInfo(String user, String password)   
    {   
        uid = user;   
        pwd = password;   
    }   
    public String toString()   
    {   
        String password=null;   
        if(pwd == null)   
        {   
        password = "NOT SET";   
        }   
        else  
        {   
            password = pwd;   
        }   
        return "logon info: \n   " + "user: " + uid +   
            "\n   logging date : " + loggingDate.toString() +   
            "\n   password: " + password;   
    }   
} 

  
  
如今咱们建立一个这个类的实例，而且串行化(serialize)它 ,而后将这个串行化对象写如磁盘。   
  

LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");   
System.out.println(logInfo.toString());   
try  
{   
   ObjectOutputStream o = new ObjectOutputStream(   
                new FileOutputStream("logInfo.out"));   
   o.writeObject(logInfo);   
   o.close();   
}   
catch(Exception e) {//deal with exception}   
  
To read the object back, we can write   
  
try  
{   
   ObjectInputStream in =new ObjectInputStream(   
                new FileInputStream("logInfo.out"));   
   LoggingInfo logInfo = (LoggingInfo)in.readObject();   
   System.out.println(logInfo.toString());   
}   
catch(Exception e) {//deal with exception}   

若是咱们运行这段代码，咱们会注意到从磁盘中读回(read——back (de-serializing))的对象打印password为"NOT SET"。这是当咱们定义pwd域为transient时，所指望的正确结果。   
如今，让咱们来看一下粗心对待transient域可能引发的潜在问题。假设咱们修改了类定义，提供给transient域一个默认值，   
代码以下：   
 
 

public class GuestLoggingInfo implements java.io.Serializable   
{   
    private Date loggingDate = new Date();   
    private String uid;   
    private transient String pwd;   
      
    GuestLoggingInfo()   
    {   
        uid = "guest";   
        pwd = "guest";   
    }   
    public String toString()   
    {   
        //same as above   
     }   
}   

如今，若是咱们穿行化GuestLoggingInfo的一个实例，将它写入磁盘，而且再将它从磁盘中读出，咱们仍然看到读回的对象打印password 为 "NOT SET"。当从磁盘中读出某个类的实例时，实际上并不会执行这个类的构造函数，   
而是载入了一个该类对象的持久化状态，并将这个状态赋值给该类的另外一个对象。