枚舉是如何保證線程安全的且其在序列化和反序列化的操作中是單例的? 要想看源碼，首先得有一個類吧，那麼枚舉類型到底是什麼類呢？是enum嗎？答案很明顯不是，enum就和class一樣，只是一個關鍵字，他並不是一個類，那麼枚舉是由什麼類維護的呢，我們簡單的 ...
枚舉是如何保證線程安全的且其在序列化和反序列化的操作中是單例的?
要想看源碼，首先得有一個類吧，那麼枚舉類型到底是什麼類呢？是enum嗎？答案很明顯不是，enum就和class一樣，只是一個關鍵字，他並不是一個類，那麼枚舉是由什麼類維護的呢，我們簡單的寫一個枚舉：
public enum T {
SPRING,SUMMER,AUTUMN,WINTER;
}然後我們使用反編譯，看看這段代碼到底是怎麼實現的，反編譯（Java的反編譯）後代碼內容如下：
public final class T extends Enum
{
private T(String s, int i)
{
super(s, i);
}
public static T[] values()
{
return (T[])$VALUES.clone();
}
public static T valueOf(String s)
{
return (T)Enum.valueOf(T, s);
}
public static final T SPRING;
public static final T SUMMER;
public static final T AUTUMN;
public static final T WINTER;
private static final T $VALUES[];
static
{
SPRING = new T("SPRING", 0);
SUMMER = new T("SUMMER", 1);
AUTUMN = new T("AUTUMN", 2);
WINTER = new T("WINTER", 3);
$VALUES = (new T[] {
SPRING, SUMMER, AUTUMN, WINTER
});
}
}通過反編譯後代碼我們可以看到，public final class T extends Enum，說明，該類是繼承了Enum類的，同時final關鍵字告訴我們，這個類也是不能被繼承的。當我們使用enmu來定義一個枚舉類型的時候，編譯器會自動幫我們創建一個final類型的類繼承Enum類,所以枚舉類型不能被繼承，我們看到這個類中有幾個屬性和方法。
我們可以看到：
public static final T SPRING;
public static final T SUMMER;
public static final T AUTUMN;
public static final T WINTER;
private static final T $VALUES[];
static
{
SPRING = new T("SPRING", 0);
SUMMER = new T("SUMMER", 1);
AUTUMN = new T("AUTUMN", 2);
WINTER = new T("WINTER", 3);
$VALUES = (new T[] {
SPRING, SUMMER, AUTUMN, WINTER
});
}都是static類型的，因為static類型的屬性會在類被載入之後被初始化，當一個Java類第一次被真正使用到的時候靜態資源被初始化、Java類的載入和初始化過程都是線程安全的。所以，創建一個enum類型是線程安全的。
為什麼用枚舉實現的單例是最好的方式
在單例模式的七種寫法中，我們看到一共有七種實現單例的方式，其中，Effective Java作者Josh Bloch提倡使用枚舉的方式，既然大神說這種方式好，那我們就要知道它為什麼好？
1. 枚舉寫法簡單
寫法簡單這個大家看看單例模式的七種寫法裡面的實現就知道區別了。
public enum EasySingleton{
INSTANCE;
}你可以通過EasySingleton.INSTANCE來訪問。
2. 枚舉自己處理序列化
我們知道，以前的所有的單例模式都有一個比較大的問題，就是一旦實現了Serializable介面之後，就不再是單例得了，因為，每次調用readObject()方法返回的都是一個新創建出來的對象，有一種解決辦法就是使用readResolve()方法來避免此事發生。但是，為了保證枚舉類型像Java規範中所說的那樣，每一個枚舉類型極其定義的枚舉變數在JVM中都是唯一的，在枚舉類型的序列化和反序列化上，Java做了特殊的規定。原文如下：
Enum constants are serialized differently than ordinary serializable or externalizable objects. The serialized form of an enum constant consists solely of its name; field values of the constant are not present in the form. To serialize an enum constant, ObjectOutputStream writes the value returned by the enum constant’s name method. To deserialize an enum constant, ObjectInputStream reads the constant name from the stream; the deserialized constant is then obtained by calling the java.lang.Enum.valueOf method, passing the constant’s enum type along with the received constant name as arguments. Like other serializable or externalizable objects, enum constants can function as the targets of back references appearing subsequently in the serialization stream. The process by which enum constants are serialized cannot be customized: any class-specific writeObject, readObject, readObjectNoData, writeReplace, and readResolve methods defined by enum types are ignored during serialization and deserialization. Similarly, any serialPersistentFields or serialVersionUID field declarations are also ignored–all enum types have a fixedserialVersionUID of 0L. Documenting serializable fields and data for enum types is unnecessary, since there is no variation in the type of data sent.
翻譯如下(限於本人的英文水平，翻譯不好的地方請見諒)：
枚舉常數的序列化方式不同於普通Serializable或者Externalizable對象的序列化(相關博文：K：java中序列化的兩種方式—Serializable或Externalizable)。枚舉常數的序列化表單僅由其name屬性構成;常數的欄位值不存在於表單中。在序列化一個枚舉常量時，ObjectOutputStream對象會寫入由枚舉常量的name方法所返回的值(一般也就是name屬性的值，也就是枚舉常量的名稱)。在反序列化枚舉常量時，通過ObjectInputStream對象從相關的流中讀取枚舉常量的name屬性值(也就是枚舉常量的名稱)，然後通過調用java.lang.Enum對象的valueOf方法，將從流中獲取的枚舉常量的枚舉類型(指的是繼承了Enum類的相關的子類)及其常量名稱(也就是枚舉常量的名稱)一起作為該方法的參數傳遞給該valueOf方法。像其它Serializable或者Externalizable對象一樣，枚舉常量可以作為隨後出現的序列化流的反向引用。枚舉常量被序列化的過程無法自定義：在序列化和反序列化期間將忽略由枚舉類型定義的任何特定於該類的writeObject，readObject，readObjectNoData，writeReplace和readResolve方法。類似地，任何serialPersistentFields或serialVersionUID欄位聲明也被將被忽略。所有的枚舉類型的fixedserialVersionUID值都是0L。記錄枚舉類型的可序列化欄位其相關的數據是不必要的，因為發送的數據類型並沒有發生變化。
以下代碼演示說明枚舉常量的序列化只保存了其枚舉常量的name屬性值
示例代碼:
package other.serial;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* 該類用於測試枚舉類的序列化是不是只是序列化了name屬性的值，也就是枚舉常量的常量名
*
* @author 學徒
*
*/
public enum AS implements Serializable
{
H("sss");
private String names;
private AS(String names)
{
this.names = names;
}
public void setNames(String names)
{
this.names = names;
}
public String getNames()
{
return this.names;
}
}
class AB
{
public static void main(String args[]) throws Exception
{
// 設置枚舉對象的names屬性值為as
AS.H.setNames("as");
System.out.println("原始枚舉對象的屬性值為" + AS.H.getNames());
// 對枚舉對象進行序列化，如果其還序列化了相關的域值，則其應該保留了names屬性域的值為as
new ObjectOutputStream(new FileOutputStream("H:\\as.txt"))
.writeObject(AS.H);
System.out.println("序列化成功");
// 修改枚舉對象中的names屬性域的屬性值
AS.H.setNames("SS");
// 對已序列化的對象進行反序列化處理，若其還序列化了枚舉對象的相關的域值，則其反序列化出來的names的屬性值應當為as
AS a = (AS) new ObjectInputStream(new FileInputStream("H:\\as.txt"))
.readObject();
System.out.println("反序列化成功");
// 通過輸出結果判斷
System.out.println("反序列化的對象的值" + a.getNames());
System.out.println(a == AS.H);
}
}
輸出結果：
原始枚舉對象的屬性值為as
序列化成功
反序列化成功
反序列化的對象的值SS
true通過分析其相應的輸出結果可以看出枚舉類型對象在序列化的時候，枚舉常數的序列化僅序列化了其name屬性值，也就是枚舉常量名稱
概括起來就是說，在序列化的時候Java僅僅是將枚舉對象的name屬性輸出到結果中，反序列化的時候則是通過java.lang.Enum的valueOf方法來根據名字查找枚舉對象。同時，編譯器是不允許任何對這種序列化機制的定製的，因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。
我們看一下這個valueOf方法：
public static <T extends Enum<T>>T valueOf(Class<T> enumType,String name)
{
T result = enumType.enumConstantDirectory().get(name);
if (result != null)
return result;
if (name == null)
throw new NullPointerException("Name is null");
throw new IllegalArgumentException( "No enum const " + enumType +"." + name);
}從代碼中可以看到，代碼會嘗試從調用enumType這個Class對象的enumConstantDirectory()方法返回的map中獲取名字為name的枚舉對象，如果不存在就會拋出異常。再進一步跟到enumConstantDirectory()方法，就會發現到最後會以反射的方式調用enumType這個類型的values()靜態方法，也就是上面我們看到的編譯器為我們創建的那個方法，然後用返回結果填充enumType這個Class對象中的enumConstantDirectory屬性。所以，JVM對序列化有保證。
