class SingletonHungary {
  private static SingletonHungary singletonHungary = new SingletonHungary();
  //將構造器設置為private禁止通過new進行實例化
  private SingletonHungary() {

  }
  public static SingletonHungary getInstance() {
    return singletonHungary;
  }
}

// 單例模式的懶漢實現1--線程不安全
class SingletonLazy1 {
  private static SingletonLazy1 singletonLazy;

  private SingletonLazy1() {

  }

  public static SingletonLazy1 getInstance() {
    if (null == singletonLazy) {
      try {
        // 模擬在創(chuàng)建對象之前做一些準備工作
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      singletonLazy = new SingletonLazy1();
    }
    return singletonLazy;
  }
}

public class SingletonLazyTest {

  public static void main(String[] args) {

    Thread2[] ThreadArr = new Thread2[10];
    for (int i = 0; i < ThreadArr.length; i++) {
      ThreadArr[i] = new Thread2();
      ThreadArr[i].start();
    }
  }

}

// 測試線程
class Thread2 extends Thread {
  @Override
  public void run() {
    System.out.println(SingletonLazy1.getInstance().hashCode());
  }
}

// 單例模式的懶漢實現2--線程安全
// 通過設置同步方法，效率太低，整個方法被加鎖
class SingletonLazy2 {
  private static SingletonLazy2 singletonLazy;

  private SingletonLazy2() {

  }

  public static synchronized SingletonLazy2 getInstance() {
    try {
      if (null == singletonLazy) {
        // 模擬在創(chuàng)建對象之前做一些準備工作
        Thread.sleep(1000);
        singletonLazy = new SingletonLazy2();
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    return singletonLazy;
  }
}

// 單例模式的懶漢實現3--線程安全
// 通過設置同步代碼塊，效率也太低，整個代碼塊被加鎖
class SingletonLazy3 {

  private static SingletonLazy3 singletonLazy;

  private SingletonLazy3() {

  }

  public static SingletonLazy3 getInstance() {
    try {
      synchronized (SingletonLazy3.class) {
        if (null == singletonLazy) {
          // 模擬在創(chuàng)建對象之前做一些準備工作
          Thread.sleep(1000);
          singletonLazy = new SingletonLazy3();
        }
      }
    } catch (InterruptedException e) {
      // TODO: handle exception
    }
    return singletonLazy;
  }
}

// 單例模式的懶漢實現4--線程不安全
// 通過設置同步代碼塊，只同步創(chuàng)建實例的代碼
// 但是還是有線程安全問題
class SingletonLazy4 {

  private static SingletonLazy4 singletonLazy;

  private SingletonLazy4() {

  }

  public static SingletonLazy4 getInstance() {
    try {
      if (null == singletonLazy) {    //代碼1
        // 模擬在創(chuàng)建對象之前做一些準備工作
        Thread.sleep(1000);
        synchronized (SingletonLazy4.class) {
          singletonLazy = new SingletonLazy4(); //代碼2
        }
      }
    } catch (InterruptedException e) {
      // TODO: handle exception
    }
    return singletonLazy;
  }
}

//單例模式的懶漢實現5--線程安全
//通過設置同步代碼塊，使用DCL雙檢查鎖機制
//使用雙檢查鎖機制成功的解決了單例模式的懶漢實現的線程不安全問題和效率問題
//DCL 也是大多數多線程結合單例模式使用的解決方案
//第一個if判斷的作用：是為了提高程序的 效率，當SingletonLazy5對象被創(chuàng)建以后，再獲取SingletonLazy5對象時就不用去驗證同步代碼塊的鎖及后面的代碼，直接返回SingletonLazy5對象
//第二個if判斷的作用：是為了解決多線程下的安全性問題，也就是保證對象的唯一。
class SingletonLazy5 {

  private static volatile SingletonLazy5 singletonLazy;

  private SingletonLazy5() {

  }

  public static SingletonLazy5 getInstance() {
    try {
      if (null == singletonLazy) {
        // 模擬在創(chuàng)建對象之前做一些準備工作
        Thread.sleep(1000);
        synchronized (SingletonLazy5.class) {
          if(null == singletonLazy) {
            singletonLazy = new SingletonLazy5();
          }
        }
      }
    } catch (InterruptedException e) {
    }
    return singletonLazy;
  }
}

//使用靜態(tài)內部類實現單例模式--線程安全
class SingletonStaticInner {
  private SingletonStaticInner() {

  }
  private static class SingletonInner {
    private static SingletonStaticInner singletonStaticInner = new SingletonStaticInner();
  }
  public static SingletonStaticInner getInstance() {
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return SingletonInner.singletonStaticInner;
  }
}

//使用靜態(tài)代碼塊實現單例模式
class SingletonStaticBlock {
  private static SingletonStaticBlock singletonStaticBlock;
  static {
    singletonStaticBlock = new SingletonStaticBlock();
  }
  public static SingletonStaticBlock getInstance() {
    return singletonStaticBlock;
  }
}

public class SingletonStaticInnerSerializeTest {

  public static void main(String[] args) {
    try {
      SingletonStaticInnerSerialize serialize = SingletonStaticInnerSerialize.getInstance();
      System.out.println(serialize.hashCode());
      //序列化
      FileOutputStream fo = new FileOutputStream("tem");
      ObjectOutputStream oo = new ObjectOutputStream(fo);
      oo.writeObject(serialize);
      oo.close();
      fo.close();
      //反序列化
      FileInputStream fi = new FileInputStream("tem");
      ObjectInputStream oi = new ObjectInputStream(fi);
      SingletonStaticInnerSerialize serialize2 = (SingletonStaticInnerSerialize) oi.readObject();
      oi.close();
      fi.close();
      System.out.println(serialize2.hashCode());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

}

//使用匿名內部類實現單例模式，在遇見序列化和反序列化的場景，得到的不是同一個實例
//解決這個問題是在序列化的時候使用readResolve方法，即去掉注釋的部分
class SingletonStaticInnerSerialize implements Serializable {

  /**
   * 2018年03月28日
   */
  private static final long serialVersionUID = 1L;

  private static class InnerClass {
    private static SingletonStaticInnerSerialize singletonStaticInnerSerialize = new SingletonStaticInnerSerialize();
  }

  public static SingletonStaticInnerSerialize getInstance() {
    return InnerClass.singletonStaticInnerSerialize;
  }

//  protected Object readResolve() {
//    System.out.println("調用了readResolve方法");
//    return InnerClass.singletonStaticInnerSerialize;
//  }
}