Java实现单例 详解Java实现单例的五种方式

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 {
        // 模拟在创建对象之前做一些准备工作
        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) {
        // 模拟在创建对象之前做一些准备工作
        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) {
          // 模拟在创建对象之前做一些准备工作
          Thread.sleep(1000);
          singletonLazy = new SingletonLazy3();
        }
      }
    } catch (InterruptedException e) {
      // TODO: handle exception
    }
    return singletonLazy;
  }
}

// 单例模式的懒汉实现4--线程不安全
// 通过设置同步代码块，只同步创建实例的代码
// 但是还是有线程安全问题
class SingletonLazy4 {

  private static SingletonLazy4 singletonLazy;

  private SingletonLazy4() {

  }

  public static SingletonLazy4 getInstance() {
    try {
      if (null == singletonLazy) {    //代码1
        // 模拟在创建对象之前做一些准备工作
        Thread.sleep(1000);
        synchronized (SingletonLazy4.class) {
          singletonLazy = new SingletonLazy4(); //代码2
        }
      }
    } catch (InterruptedException e) {
      // TODO: handle exception
    }
    return singletonLazy;
  }
}

//单例模式的懒汉实现5--线程安全
//通过设置同步代码块，使用DCL双检查锁机制
//使用双检查锁机制成功的解决了单例模式的懒汉实现的线程不安全问题和效率问题
//DCL 也是大多数多线程结合单例模式使用的解决方案
//第一个if判断的作用：是为了提高程序的 效率，当SingletonLazy5对象被创建以后，再获取SingletonLazy5对象时就不用去验证同步代码块的锁及后面的代码，直接返回SingletonLazy5对象
//第二个if判断的作用：是为了解决多线程下的安全性问题，也就是保证对象的唯一。
class SingletonLazy5 {

  private static volatile SingletonLazy5 singletonLazy;

  private SingletonLazy5() {

  }

  public static SingletonLazy5 getInstance() {
    try {
      if (null == singletonLazy) {
        // 模拟在创建对象之前做一些准备工作
        Thread.sleep(1000);
        synchronized (SingletonLazy5.class) {
          if(null == singletonLazy) {
            singletonLazy = new SingletonLazy5();
          }
        }
      }
    } catch (InterruptedException e) {
    }
    return singletonLazy;
  }
}

//使用静态内部类实现单例模式--线程安全
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;
  }
}

//使用静态代码块实现单例模式
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;
//  }
}