.

深入理解Java中的不可變物件

不可變物件想必大部分朋友都不陌生,大家在平時寫程式碼的過程中100%會使用到不可變物件,比如最常見的String物件、包裝器物件等,那麼到底為何Java語言要這麼設計,真正意圖和考慮點是什麼?可能一些朋友沒有細想過這些問題,今天我們就來聊聊跟不可變物件有關的話題。

 以下是本文目錄大綱:

一.什麼是不可變物件

二.深入理解不可變性

三.如何建立不可變物件

四.不可變物件真的"完全不可改變"嗎?

一.什麼是不可變物件

下面是《Effective Java》這本書對於不可變物件的定義:

1

不可變物件(Immutable Object):物件一旦被建立後,物件所有的狀態及屬性在其生命週期內不會發生任何變化。

從不可變物件的定義來看,其實比較簡單,就是一個物件在建立後,不能對該物件進行任何更改。比如下面這段程式碼:

public class ImmutableObject {
    private int value;
     
    public ImmutableObject(int value) {
        this.value = value;
    }
     
    public int getValue() {
        return this.value;
    }
}

由於ImmutableObject不提供任何setter方法,並且成員變數value是基本資料型別,getter方法返回的是value的拷貝,所以一旦ImmutableObject例項被建立後,該例項的狀態無法再進行更改,因此該類具備不可變性。

再比如我們平時用的最多的String:

public class Test {
 
    public static void main(String[] args) {
        String str = "I love java";
        String str1 = str;
 
        System.out.println("after replace str:" + str.replace("java", "Java"));
        System.out.println("after replace str1:" + str1);
    }
}

輸出結果:

 

 

 

 

從輸出結果可以看出,在對str進行了字串替換替換之後,str1指向的字串物件仍然沒有發生變化。

二.深入理解不可變性

我們是否考慮過一個問題:假如Java中的String、包裝器類設計成可變的ok麼?如果String物件可變了,會帶來哪些問題?

我們這一節主要來聊聊不可變物件存在的意義。

1)讓併發程式設計變得更簡單

說到併發程式設計,可能很多朋友都會覺得最苦惱的事情就是如何處理共享資源的互斥訪問,可能稍不留神,就會導致程式碼上線後出現莫名其妙的問題,並且大部分併發問題都不是太容易進行定位和復現。所以即使是非常有經驗的程式設計師,在進行併發程式設計時,也會非常的小心,內心如履薄冰。

大多數情況下,對於資源互斥訪問的場景,都是採用加鎖的方式來實現對資源的序列訪問,來保證併發安全,如synchronize關鍵字,Lock鎖等。但是這種方案最大的一個難點在於:在進行加鎖和解鎖時需要非常地慎重。如果加鎖或者解鎖時機稍有一點偏差,就可能會引發重大問題,然而這個問題Java編譯器無法發現,在進行單元測試、整合測試時也發現不了,甚至程式上線後也能正常執行,但是可能突然在某一天,它就莫名其妙地出現了。

然而人類是機智的,既然採用序列方式來訪問共享資源這麼容易出現問題,那麼有沒有其他辦法來解決呢?答案是肯定的。

事實上,引起執行緒安全問題的根本原因在於:多個執行緒需要同時訪問同一個共享資源。

假如沒有共享資源,那麼多執行緒安全問題就自然解決了,Java中提供ThreadLocal機制就是採取的這種思想。

然而大多數時候,執行緒間是需要使用共享資源互通訊息的,如果共享資源在建立之後就完全不再變更,如同一個常量,而多個執行緒間併發讀取該共享資源是不會存在線上安全問題的,因為所有執行緒無論何時讀取該共享資源,總是能獲取到一致的、完整的資源狀態。

不可變物件就是這樣一種在建立之後就不再變更的物件,這種特性使得它們天生支援執行緒安全,讓併發程式設計變得更簡單。

我們來看一個例子:

public class SynchronizedRGB {
    private int red;  // 顏色對應的紅色值
    private int green; // 顏色對應的綠色值
    private int blue;  // 顏色對應的藍色值
    private String name; // 顏色名稱
 
    private void check(int red, int green, int blue) {
        if (red < 0 || red > 255 || green < 0 || green > 255
                || blue < 0 || blue > 255) {
            throw new IllegalArgumentException();
        }
    }
 
    public SynchronizedRGB(int red, int green, int blue, String name) {
        check(red, green, blue);
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.name = name;
    }
 
    public void set(int red, int green, int blue, String name) {
        check(red, green, blue);
        synchronized (this) {
            this.red = red;
            this.green = green;
            this.blue = blue;
            this.name = name;
        }
    }
 
    public synchronized int getRGB() {
        return ((red << 16) | (green << 8) | blue);
    }
 
    public synchronized String getName() {
        return name;
    }
}

例如一個有個執行緒1執行了以下程式碼:

SynchronizedRGB color =  new SynchronizedRGB(0, 0, 0, "Pitch Black");
int myColorInt = color.getRGB();      // Statement1
String myColorName = color.getName(); // Statement2

然後有另外一個執行緒2在Statement 1之後、Statement 2之前呼叫了color.set方法:

color.set(0, 255, 0, "Green");

那麼線上程1中變數myColorInt的值和myColorName的值就會不匹配。為了避免出現這樣的結果,必須要像下面這樣把這兩條語句繫結到一塊執行:

synchronized (color) {
    int myColorInt = color.getRGB();
    String myColorName = color.getName();
}

假如SynchronizedRGB是不可變類,那麼就不會出現這個問題,比如將SynchronizedRGB改成下面這種實現方式:

public class ImmutableRGB {
    private int red;
    private int green;
    private int blue;
    private String name;
 
    private void check(int red, int green, int blue) {
        if (red < 0 || red > 255 || green < 0 || green > 255
                || blue < 0 || blue > 255) {
            throw new IllegalArgumentException();
        }
    }
 
    public ImmutableRGB(int red, int green, int blue, String name) {
        check(red, green, blue);
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.name = name;
    }
 
    public ImmutableRGB set(int red, int green, int blue, String name) {
        return new ImmutableRGB(red, green, blue, name);
    }
 
    public int getRGB() {
        return ((red << 16) | (green << 8) | blue);
    }
 
    public String getName() {
        return name;
    }
}

由於set方法並沒有改變原來的物件,而是新建立了一個物件,所以無論執行緒1或者執行緒2怎麼呼叫set方法,都不會出現併發訪問導致的資料不一致的問題。

2)消除副作用

很多時候一些很嚴重的bug是由於一個很小的副作用引起的,並且由於副作用通常不容易被察覺,所以很難在編寫程式碼以及程式碼review過程中發現,並且即使發現了也可能會花費很大的精力才能定位出來。

舉個簡單的例子:

class Person {
    private int age;   // 年齡
    private String identityCardID;  // 身份證號碼
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getIdentityCardID() {
        return identityCardID;
    }
 
    public void setIdentityCardID(String identityCardID) {
        this.identityCardID = identityCardID;
    }
}
 
 
public class Test {
 
    public static void main(String[] args) {
        Person jack = new Person();
        jack.setAge(101);
        jack.setIdentityCardID("42118220090315234X");
 
        System.out.println(validAge(jack));
 
 // 後續使用可能沒有察覺到jack的age被修改了
 // 為後續埋下了不容易察覺的問題
 
    }
 
    public static boolean validAge(Person person) {
        if (person.getAge() >= 100) {
            person.setAge(100);  // 此處產生了副作用
            return false;
        }
        return true;
    }
 
}

validAge函式本身只是對age大小進行判斷,但是在這個函式裡面有一個副作用,就是對引數person指向的物件進行了修改,導致在外部的jack指向的物件也發生了變化。

如果Person物件是不可變的,在validAge函式中是無法對引數person進行修改的,從而避免了validAge出現副作用,減少了出錯的概率。

3)減少容器使用過程出錯的概率

我們在使用HashSet時,如果HashSet中元素物件的狀態可變,就會出現元素丟失的情況,比如下面這個例子:

class Person {
    private int age;   // 年齡
    private String identityCardID;  // 身份證號碼
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getIdentityCardID() {
        return identityCardID;
    }
 
    public void setIdentityCardID(String identityCardID) {
        this.identityCardID = identityCardID;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
 
        if (!(obj instanceof  Person)) {
            return false;
        }
        Person personObj = (Person) obj;
        return this.age == personObj.getAge() && this.identityCardID.equals(personObj.getIdentityCardID());
    }
 
    @Override
    public int hashCode() {
        return age * 37 + identityCardID.hashCode();
    }
}
 
 
public class Test {
 
    public static void main(String[] args) {
        Person jack = new Person();
        jack.setAge(10);
        jack.setIdentityCardID("42118220090315234X");
 
        Set<Person> personSet = new HashSet<Person>();
        personSet.add(jack);
 
        jack.setAge(11);
 
        System.out.println(personSet.contains(jack));
 
    }
}

輸出結果:

 

 

 

 

所以在Java中,對於String、包裝器這些類,我們經常會用他們來作為HashMap的key,試想一下如果這些類是可變的,將會發生什麼?後果不可預知,這將會大大增加Java程式碼編寫的難度。

三.如何建立不可變物件

通常來說,建立不可變類原則有以下幾條:

1)所有成員變數必須是private

2)最好同時用final修飾(非必須)

3)不提供能夠修改原有物件狀態的方法

  • 最常見的方式是不提供setter方法
  • 如果提供修改方法,需要新建立一個物件,並在新建立的物件上進行修改

4)通過構造器初始化所有成員變數,引用型別的成員變數必須進行深拷貝(deep copy)

5)getter方法不能對外洩露this引用以及成員變數的引用

6)最好不允許類被繼承(非必須)

JDK中提供了一系列方法方便我們建立不可變集合,如:

Collections.unmodifiableList(List<? extends T> list)

另外,在Google的Guava包中也提供了一系列方法來建立不可變集合,如:

ImmutableList.copyOf(list)

這2種方式雖然都能建立不可變list,但是兩者是有區別的,JDK自帶提供的方式實際上創建出來的不是真正意義上的不可變集合,看unmodifiableList方法的實現就知道了:

 

 

 

 

 

 

 

 

可以看出,實際上UnmodifiableList是將入參list的引用複製了一份,同時將所有的修改方法丟擲UnsupportedOperationException。因此如果在外部修改了入參list,實際上會影響到UnmodifiableList,而Guava包提供的ImmutableList是真正意義上的不可變集合,它實際上是對入參list進行了深拷貝。看下面這段測試程式碼的結果便一目瞭然:

public class Test {
 
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        System.out.println(list);
 
        List unmodifiableList = Collections.unmodifiableList(list);
        ImmutableList immutableList = ImmutableList.copyOf(list);
 
        list.add(2);
        System.out.println(unmodifiableList);
        System.out.println(immutableList);
 
    }
 
}

輸出結果:

 

 

 

 

四.不可變物件真的"完全不可改變"嗎?

不可變物件雖然具備不可變性,但是不是"完全不可變"的,這裡打上引號是因為通過反射的手段是可以改變不可變物件的狀態的。

大家看到這裡可能有疑惑了,為什麼既然能改變,為何還叫不可變物件?這裡面大家不要誤會不可變的本意,從不可變物件的意義分析能看出來物件的不可變性只是用來輔助幫助大家更簡單地去編寫程式碼,減少程式編寫過程中出錯的概率,這是不可變物件的初衷。如果真要靠通過反射來改變一個物件的狀態,此時編寫程式碼的人也應該會意識到此類在設計的時候就不希望其狀態被更改,從而引起編寫程式碼的人的注意。下面是通過反射方式改變不可變物件的例子:

 

public class Test {
    public static void main(String[] args) throws Exception {
        String s = "Hello World";
        System.out.println("s = " + s);
 
        Field valueFieldOfString = String.class.getDeclaredField("value");
        valueFieldOfString.setAccessible(true);
 
        char[] value = (char[]) valueFieldOfString.get(s);
        value[5] = '_';
        System.out.println("s = " + s);
    }
 
}

輸出結果:

 

 

 

歡迎工作一到五年的Java工程師朋友們加入Java程式設計師開發: 721575865

群內提供免費的Java架構學習資料(裡面有高可用、高併發、高效能及分散式、Jvm效能調優、Spring原始碼,MyBatis,Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多個知識點的架構資料)合理利用自己每一分每一秒的時間來學習提升自己,不要再用"沒有時間“來掩飾自己思想上的懶惰!趁年輕,使勁拼,給未來的