Java transient關鍵字

    Volatile修飾的成員變量在每次被線程訪問時，都強迫從主內存中重讀該成員變量的值。而且，當成員變量發生變化時，強迫線程將變化值回寫到主內存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。   

    Java語言規范中指出：為了獲得最佳速度，允許線程保存共享成員變量的私有拷貝，而且只當線程進入或者離開同步代碼塊時才與共享成員變量的原始值對比。   
 
    這樣當多個線程同時與某個對象交互時，就必須要注意到要讓線程及時的得到共享成員變量的變化。   
  
    而volatile關鍵字就是提示VM：對於這個成員變量不能保存它的私有拷貝，而應直接與共享成員變量交互。   

    使用建議：在兩個或者更多的線程訪問的成員變量上使用volatile。當要訪問的變量已在synchronized代碼塊中，或者為常量時，不必使用。由於使用volatile屏蔽掉了VM中必要的代碼優化，所以在效率上比較低，因此一定在必要時才使用此關鍵字。   
  
java關鍵字Transient

    Java的serialization提供了一種持久化對象實例的機制。當持久化對象時，可能有一個特殊的對象數據成員，我們不想用serialization機制來保存它。為了在一個特定對象的一個域上關閉serialization，可以在這個域前加上關鍵字transient。   
    transient是Java語言的關鍵字，用來表示一個域不是該對象串行化的一部分。當一個對象被串行化的時候，transient型變量的值不包括在串行化的表示中，然而非transient型的變量是被包括進去的。  
注意static變量也是可以串行化的

首先，讓我們看一些Java serialization的代碼： 

import java.util.Date;

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)它 ,然后將這個串行化對象寫如磁盤。

package com.wms.test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class TestTransient implements java.io.Serializable {  
    
    public static void main(String[] args) {
        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 logInfoIn = (LoggingInfo)in.readObject();  
           System.out.println(logInfoIn.toString());  
        } catch(Exception e) {
            //deal with exception 
        }
    }
}  

 

輸出結果：

logon info: 
   user: MIKE
   logging date : Wed Apr 13 22:13:44 CST 2016
   password: MECHANICS
logon info: 
   user: MIKE
   logging date : Wed Apr 13 22:13:44 CST 2016
   password: NOT SET

如果我們運行這段代碼，我們會注意到從磁盤中讀回(read)的對象打印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"。當從磁盤中讀出某個類的實例時，實際上並不會執行這個類的構造函數，而是載入了一個該類對象的持久化狀態，並將這個狀態賦值給該類的另一個對象。