程式碼例項解讀如何安全釋出物件

package io.binghe.concurrency.example.publish;
import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;
@Slf4j
public class UnsafePublish {
 private String[] states = {"a", "b", "c"};
 public String[] getStates(){
 return states;
    }
 public static void main(String[] args){
 UnsafePublish unsafePublish = new UnsafePublish();
 log.info("{}", Arrays.toString(unsafePublish.getStates()));
 unsafePublish.getStates()[0] = "d";
 log.info("{}", Arrays.toString(unsafePublish.getStates()));
    }
}

package io.binghe.concurrency.example.publish;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Escape {
 private int thisCanBeEscape = 0;
 public Escape(){
 new InnerClass();
    }
 private class InnerClass{
 public InnerClass(){
 log.info("{}", Escape.this.thisCanBeEscape);
        }
    }
 public static void main(String[] args){
 new Escape();
    }
}

package io.binghe.concurrency.example.singleton;
/**
 * @author binghe
 * @version 1.0.0
 * @description 懶漢模式，單例例項在第一次使用的時候進行建立，這個類是執行緒不安全的
 */
public class SingletonExample1 {
 private SingletonExample1(){}
 private static SingletonExample1 instance = null;
 public static SingletonExample1 getInstance(){
 //多個執行緒同時呼叫，可能會建立多個物件
 if (instance == null){
            instance = new SingletonExample1();
        }
 return instance;
    }
}

package io.binghe.concurrency.example.singleton;
/**
 * @author binghe
 * @version 1.0.0
 * @description 餓漢模式，單例例項在類裝載的時候進行建立，是執行緒安全的
 */
public class SingletonExample2 {
 private SingletonExample2(){}
 private static SingletonExample2 instance = new SingletonExample2();
 public static SingletonExample2 getInstance(){
 return instance;
    }
}

package io.binghe.concurrency.example.singleton;
/**
 * @author binghe
 * @version 1.0.0
 * @description 懶漢模式，單例例項在第一次使用的時候進行建立，這個類是執行緒安全的，但是這個寫法不推薦
 */
public class SingletonExample3 {
 private SingletonExample3(){}
 private static SingletonExample3 instance = null;
 public static synchronized SingletonExample3 getInstance(){
 if (instance == null){
            instance = new SingletonExample3();
        }
 return instance;
    }
}

package io.binghe.concurrency.example.singleton;
/**
 * @author binghe
 * @version 1.0.0
 * @description 懶漢模式（雙重鎖同步鎖單例模式）
 *              單例例項在第一次使用的時候進行建立，這個類不是執行緒安全的
 */
public class SingletonExample4 {
 private SingletonExample4(){}
 private static SingletonExample4 instance = null;
 //執行緒不安全
 //當執行instance = new SingletonExample4();這行程式碼時，CPU會執行如下指令：
 //1.memory = allocate() 分配物件的記憶體空間
 //2.ctorInstance() 初始化物件
 //3.instance = memory 設定instance指向剛分配的記憶體
 //單純執行以上三步沒啥問題，但是在多執行緒情況下，可能會發生指令重排序。
 // 指令重排序對單執行緒沒有影響，單執行緒下CPU可以按照順序執行以上三個步驟，但是在多執行緒下，如果發生了指令重排序，則會打亂上面的三個步驟。
 //如果發生了JVM和CPU優化，發生重排序時，可能會按照下面的順序執行：
 //1.memory = allocate() 分配物件的記憶體空間
 //3.instance = memory 設定instance指向剛分配的記憶體
 //2.ctorInstance() 初始化物件
 //假設目前有兩個執行緒A和B同時執行getInstance()方法，A執行緒執行到instance = new SingletonExample4(); B執行緒剛執行到第一個 if (instance == null){處，
 //如果按照1.3.2的順序，假設執行緒A執行到3.instance = memory 設定instance指向剛分配的記憶體，此時，執行緒B判斷instance已經有值，就會直接return instance;
 //而實際上，執行緒A還未執行2.ctorInstance() 初始化物件，也就是說執行緒B拿到的instance物件還未進行初始化，這個未初始化的instance物件一旦被執行緒B使用，就會出現問題。
 public static SingletonExample4 getInstance(){
 if (instance == null){
 synchronized (SingletonExample4.class){
 if(instance == null){
                    instance = new SingletonExample4();
                }
            }
        }
 return instance;
    }
}

package io.binghe.concurrency.example.singleton;
/**
 * @author binghe
 * @version 1.0.0
 * @description 懶漢模式（雙重鎖同步鎖單例模式）
 *              單例例項在第一次使用的時候進行建立，這個類是執行緒安全的
 */
public class SingletonExample5 {
 private SingletonExample5(){}
 //單例物件  volatile + 雙重檢測機制來禁止指令重排
 private volatile static SingletonExample5 instance = null;
 public static SingletonExample5 getInstance(){
 if (instance == null){
 synchronized (SingletonExample5.class){
 if(instance == null){
                    instance = new SingletonExample5();
                }
            }
        }
 return instance;
    }
}

package io.binghe.concurrency.example.singleton;
/**
 * @author binghe
 * @version 1.0.0
 * @description 餓漢模式，單例例項在類裝載的時候進行建立，是執行緒安全的
 */
public class SingletonExample6 {
 private SingletonExample6(){}
 private static SingletonExample6 instance = null;
 static {
        instance = new SingletonExample6();
    }
 public static SingletonExample6 getInstance(){
 return instance;
    }
}

package io.binghe.concurrency.example.singleton;
/**
 * @author binghe
 * @version 1.0.0
 * @description 列舉方式進行例項化，是執行緒安全的，此種方式也是執行緒最安全的
 */
public class SingletonExample7 {
 private SingletonExample7(){}
 public static SingletonExample7 getInstance(){
 return Singleton.INSTANCE.getInstance();
    }
 private enum Singleton{
        INSTANCE;
 private SingletonExample7 singleton;
 //JVM保證這個方法絕對只調用一次
 Singleton(){
            singleton = new SingletonExample7();
        }
 public SingletonExample7 getInstance(){
 return singleton;
        }
    }
}