深入探索 Java 物件創建與引用細節：Clone 和finalize 特性，以及強、軟、弱、虛引用

// java.lang.Cloneable

public interface Cloneable {
}

● 標示界面 是甚麽？

標示介面通常是拿來判斷的，標示界面並不具有任何需要實作的方法

● Protected 方法

介於它是 Protected 方法，所以如果要讓外部呼叫，我們可以使用 overload 的技巧，對外開放

● 如果我們呼叫 clone 方法，但並沒有實作 Cloneable 介面，那就會拋出 CloneNotSupportedException 異常

class NoCloneable {

    @Override
    public NoCloneable clone() {
        try {
            return (NoCloneable) super.clone();
        } catch (CloneNotSupportedException e) {
            // 例外轉譯
            throw new AssertionError();
        }
    }

}

● 只要我們標示該介面是 Cloneable 就不會拋出異常

class WithCloneable implements Cloneable {

    @Override
    public WithCloneable clone() {
        try {
            return (WithCloneable) super.clone();
        } catch (CloneNotSupportedException e) {
            // 例外轉譯
            throw new AssertionError();
        }
    }

}

class WithCloneable implements Cloneable {

    public String myStr = "Hello";

    public final int[] intArray = new int[1000];

    @Override
    public WithCloneable clone() {
        try {
            return (WithCloneable) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    public static void main(String[] args) {

        WithCloneable wc = new WithCloneable();

        WithCloneable c1 = wc.clone();

        System.out.println("Is clone object hashcode same: "
                + (wc.hashCode() == c1.hashCode()));

        System.out.println("Before set clone object's array(hashcode): "
                + (Arrays.hashCode(wc.intArray) == Arrays.hashCode(c1.intArray)));

        System.out.println("Before set clone object's string(hashcode): "
                + (wc.myStr.hashCode() == c1.hashCode()));

        System.out.println("Before set clone object's string(value): "
                + (wc.myStr.equals(c1.myStr)));

        System.out.println();

        c1.intArray[0] = 1000;
        System.out.println("After set clone object's array(hashcode): "
                + (Arrays.hashCode(wc.intArray) == Arrays.hashCode(c1.intArray)));

        c1.myStr = "World";
        System.out.println("After set clone object's string(value): "
                + (wc.myStr.equals(c1.myStr)));

        System.out.println("After set clone object's string(value): "
                + (wc.myStr.equals(c1.myStr)));
    }

}

深拷貝：如果有需拷貝全新參考類型，那要則需要自己手動做參考類型的 clone 方法

// java.io.Serializable

public interface Serializable {
}

這類似一種 Copy on write 的技術

● 示意圖如下，在更改物件之前，指向同一個參考物件

● 示意圖如下，在更改物件之後，指向全新的參考物件

class AccountInfo implements Serializable {
    public final String name;
    public final long id;
    public final String password;

    public final String[] otherMessages = new String[1000];

    public AccountInfo() {
        this.name = "";
        this.id = -1;
        this.password = "-";


        System.out.println("Construct without params");
    }

    public AccountInfo(String name, long id, String password) {
        this.name = name;
        this.id = id;
        this.password = password;

        System.out.println("Construct with params");
    }

    @Override
    public String toString() {
        return "Name: " + name + "\n" +
                "id: " + id + "\n" +
                "password: " + password + "\n" +
                "otherMessages: " + Arrays.toString(otherMessages);
    }

    public static void main(String[] args) {
        String filename = "DemoAccount";

        // 序列化
        AccountInfo accountInfo = new AccountInfo("Alien", 9527, "HelloWorld");

        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename))){
            oos.writeObject(accountInfo);
            oos.flush();

            System.out.println("寫入對象成功，物件原本 hashcode: " + accountInfo.hashCode() + "\n");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try (ObjectInputStream oos = new ObjectInputStream(new FileInputStream(filename))){
            AccountInfo deserializeObj = (AccountInfo) oos.readObject();

            System.out.println("讀取對象成功，反序列化後 hashcode: " + deserializeObj.hashCode());
            System.out.println(("Is same content: " + accountInfo).equals(deserializeObj.toString()));

            System.out.println("clone's array hashcode: " + Arrays.hashCode(deserializeObj.otherMessages));
            System.out.println("original's array hashcode: " + Arrays.hashCode(accountInfo.otherMessages) + "\n");

            accountInfo.otherMessages[0] = "123";

            System.out.println("clone's array index 0: " + deserializeObj.otherMessages[0]);
            System.out.println("clone's array index 0: " + Arrays.hashCode(deserializeObj.otherMessages) + "\n");

            System.out.println("original's array index 0: " + accountInfo.otherMessages[0]);
            System.out.println("original's array index 0: " + Arrays.hashCode(accountInfo.otherMessages) + "\n");
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

package GC;

public class testFinalize {

    public static testFinalize intance = null;

    @Override
    public void finalize() {
        System.out.println("finalize work");
        // 牽引回 GC Root
        intance = this;
    }

    public static void main(String[] args) throws InterruptedException {
        intance = new testFinalize();
        intance = null;

        // First：手動 GC
        System.gc();		

        // 由於 finally Thread 優先權太低，所以延遲主線程
        Thread.sleep(1000);		
        if(intance == null) {
            System.out.println("First intance == null");
        } else {
            System.out.println("First intance != null");
        }

        intance = null;

        // Second：手動 GC
        System.gc();		
        Thread.sleep(1000);
        if(intance == null) {
            System.out.println("Second intance == null");
        } else {
            System.out.println("Second intance != null");
        }
    }

}

--實做結果--

● Object#finalize 方法也被遺棄，不再推薦被使用

● 為何需要休眠一秒？

因為 finalize 線程是運行在別的線程，優先權沒有主線程高，不一定會被先執行到，fialize 可以算是歷史的產物

如果沒有休眠可以看到下方的 finalize 根本來不及拯救

public class GCTest {

    private static GCTest gcTest;

    @Override
    protected void finalize() throws Throwable {
        System.out.println("GC - finalize");

        gcTest = this;

        // 並不會產生異常，GC 會吞下這筆異常
        throw new Exception("Test exception");
    }

    public static void main(String[] args) throws InterruptedException {
        gcTest = new GCTest();

        System.out.println("Before GC, GCTest: " + gcTest);
        gcTest = null;

        System.gc();
        Thread.sleep(1000);

        System.out.println("After GC, GCTest: " + gcTest);

    }

}

使用 new SoftReference<>(str)

str = null

● 如何觸發 OOM

A. 由於 JVM 通常在 內存足夠的狀況下不會回收 SoftReference 物件，所以在這邊設定堆區的 最大 -Xmx、-Xms 最小值

B. 手動創建超出堆區大小的強引用（list.add(new byte[1024*1024])），就會發生 OOM

這時 GC 就會被喚起去檢查 SoftReference 物件

new WeakReference<>(str)

不管記憶體是否足夠，只要觸發 GC 後，被發現就會直接回收

這種物件的引用在 JVM 中的 Java 棧，而物件本身則在 Java 堆中；在離開該方法後，引用就不會再可達！這種就會自動回收

void showMessage(String... strings) {
    StringBuffer stringBuffer = new StringBuffer();

    for (String string : strings) {
        stringBuffer.append(string).append("\t");
    }

    System.out.println(stringBuffer.toString());

    // 沒必要！
    // 因為離開該方法後該 StringBuffer 物件就會被回收（非即時）
    stringBuffer = null;
}

class MessageHandler {

    private List<StringBuffer> history = new ArrayList<>();

    void collectMessage(String... strings) {
        StringBuffer stringBuffer = new StringBuffer();

        for (String string : strings) {
            stringBuffer.append(string).append("\t");
        }

        // 將區域變量中的物件 加入到 全局變量，該物件就不會被回收（因為可達）
        history.add(stringBuffer);
    }

    String popMessage(int index) throws IllegalAccessException {
        if (index >= history.size()) {
            throw new IllegalAccessException();
        }

        StringBuffer tmp = history.get(index);
        String result = tmp.toString();

        // 移除全局變量對物件的引用
        history.remove(tmp);
        // 手動解除引用
        tmp = null;

        return result;
    }

}

class ImmutableData {

    public final String message;
    public final String name;

    ImmutableData(String message, String name) {
        this.message = message;
        this.name = name;
    }
}