詳解Java實(shí)現(xiàn)單例的五種方式

class SingletonHungary {
  private static SingletonHungary singletonHungary = new SingletonHungary();
  //將構(gòu)造器設(shè)置為private禁止通過new進(jìn)行實(shí)例化
  private SingletonHungary() {

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

// 單例模式的懶漢實(shí)現(xiàn)1--線程不安全
class SingletonLazy1 {
  private static SingletonLazy1 singletonLazy;

  private SingletonLazy1() {

  }

  public static SingletonLazy1 getInstance() {
    if (null == singletonLazy) {
      try {
        // 模擬在創(chuàng)建對(duì)象之前做一些準(zhǔn)備工作
        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();
    }
  }

}

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

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

  private SingletonLazy2() {

  }

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

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

  private static SingletonLazy3 singletonLazy;

  private SingletonLazy3() {

  }

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

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

  private static SingletonLazy4 singletonLazy;

  private SingletonLazy4() {

  }

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

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

  private static volatile SingletonLazy5 singletonLazy;

  private SingletonLazy5() {

  }

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

//使用靜態(tài)內(nèi)部類實(shí)現(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)代碼塊實(shí)現(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();
    }
  }

}

//使用匿名內(nèi)部類實(shí)現(xiàn)單例模式，在遇見序列化和反序列化的場(chǎng)景，得到的不是同一個(gè)實(shí)例
//解決這個(gè)問題是在序列化的時(shí)候使用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("調(diào)用了readResolve方法");
//    return InnerClass.singletonStaticInnerSerialize;
//  }
}