单例设计模式

单例设计模式

设计模式介绍

懒汉式

懒汉式实现主要是用户在调用的时候才初始化对象,且是线程不安全的

public class Singleton {  
     private static Singleton instance;  
      private Singleton (){}   
      public static Singleton getInstance() {  
      if (instance == null) {  
         instance = new Singleton();  
     }  
        return instance;  
      }  
 }  

饿汉式

饿汉式有个静态的全局变量,java在创建类的时候就会初始化对象,是线程安全的

public class Singleton {
  private static Singleton instance = new Singleton();

  private Singleton() {}

  public static Singleton getInstance() {
    return instance;
  }
}

双重检查锁

public class Singleton {
  private static Singleton singleton;

  private Singleton() {}

  public static Singleton getSingleton() {
    if (singleton == null) {
      synchronized (Singleton.class) {
        if (singleton == null) {
          singleton = new Singleton();
        }
      }
    }
    return singleton;
  }
}

这段代码看起来很完美，很可惜，它是有问题。主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

1.给 instance 分配内存

2.调用 Singleton 的构造函数来初始化成员变量

3.将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。

如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

我们只需要将 instance 变量声明成 volatile 就可以了。代码如下所示:

public class Singleton {
  private volatile static Singleton singleton;

  private Singleton() {}

  public static Singleton getSingleton() {
    if (singleton == null) {
      synchronized (Singleton.class) {
        if (singleton == null) {
          singleton = new Singleton();
        }
      }
    }
    return singleton;
  }
}

使用volatile可以实现线程安全的原因是

volatile有两个功能:

• 可见性

• 禁止重排

主要是volatile生成了内存屏障,禁止指令重排

内部类实现

public class Singleton {
  private static class SingletonHolder {
    private static final Singleton INSTANCE = new Singleton();
  }

  private Singleton() {}

  public static final Singleton getInstance() {
    return SingletonHolder.INSTANCE;
  }
}

这种写法仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候:

• 不会进行同步

• 没有性能缺陷

• 也不依赖 JDK 版本。

枚举实现

public enum EasySingleton{
    INSTANCE;
}

我们可以通过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。

创建枚举默认就是线程安全的，所以不需要担心双重检查锁，而且还能防止反序列化导致重新创建新的对象。

但是还是很少看到有人这样写，可能是因为不太熟悉吧。

总结:

有两个问题需要注意：

• 如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类 装载器，

  这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。

• 如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。

  不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。

问题一解决方法:

private static Class getClass(String classname)throws ClassNotFoundException{
        ClassLoader classLoader=Thread.currentThread().getContextClassLoader();
        if(classLoader==null)
            classLoader=Singleton.class.getClassLoader();
        return(classLoader.loadClass(classname));
    }
}

问题而解决方法

public class Singleton implements java.io.Serializable {
  public static Singleton INSTANCE = new Singleton();

  protected Singleton() {
  }

  private Object readResolve() {
    return INSTANCE;
  }
}   

虚拟机在反序列化的时候会调用默认的readResolve方法,只要实现自定义的readResolve方法

方法里返回单例对象即可。