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

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

// 單例模式的懶漢實現(xiàn)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());
  }
}

// 單例模式的懶漢實現(xiàn)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;
  }
}

// 單例模式的懶漢實現(xiàn)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;
  }
}

// 單例模式的懶漢實現(xiàn)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;
  }
}

//單例模式的懶漢實現(xiàn)5--線程安全
//通過設置同步代碼塊，使用DCL雙檢查鎖機制
//使用雙檢查鎖機制成功的解決了單例模式的懶漢實現(xiàn)的線程不安全問題和效率問題
//DCL 也是大多數(shù)多線程結合單例模式使用的解決方案
//第一個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)內部類實現(xiàn)單例模式--線程安全
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)代碼塊實現(xiàn)單例模式
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();
    }
  }

}

//使用匿名內部類實現(xiàn)單例模式，在遇見序列化和反序列化的場景，得到的不是同一個實例
//解決這個問題是在序列化的時候使用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;
//  }
}