java 单例设计_java单例设计模式

1.应用场景：

当需要保证类在内存中的对象唯一性，可以使用单例模式，

不想创建多个实例浪费资源，或者避免多个实例由于多次调用

而出现错误。一般写工具类，线程池，缓存，数据库等可以用到。

2.各种各样的单例写法

1.饿汉模式

public class Singleton {

private static Singleton instance = new Singleton();

private Singleton() {

}

public static Singleton getInstance() {

return instance;

}

}

获取单例对象：Singleton instace = Singleton.getInstance();

优点：类加载的时候就完成实例化，避免线程同步问题

缺点：由于在类加载的时候就进行了实例化，所以没有达到Lazy Loading(懒加载)

的效果，即使我们没用到这个实例，但是他还是会加载，从而造成内存浪费(可以忽略，

最常用的一种)。

2.懒汉模式(线程不安全)

public class Singleton {

private static Singleton instance = null;

private Singleton() {

}

public static Singleton getInstance() {

if(null == instance){

instance = new Singleton();

}

return instance;

}

}

尽管达到了懒加载，但是却存在线程安全问题，比如有两个线程，刚好都

执行完if(instance == null)，接着准备执行instance = new Singleton()

语句，这样的结果会导致我们实例化了两个Singleton对象，这就是懒汉单例

模式可能会引发的线程安全问题，解决这个方法，我们可以对getInstance方法加锁。

3.懒汉模式(线程安全，但效率低)

public class Singleton {

private static Singleton instance = null;

private Singleton() {

}

public static synchronized Singleton getInstance() {

if(null == instance){

instance = new Singleton();

}

return instance;

}

}

尽管保证了线程安全，但是每个线程在想要获得实例时，执行getInstance()

方法都需要进行同步，而实例化代码只需执行一次就够了，后面获取该实例，

直接return即可，方法进行同步效率太低，需要改进。还有一种写法是：

synchronized (Singleton.class) { instance = new Singleton(); }

这样一样是线程不安全的，如果你想使用懒汉模式的话，推荐使用下面的：

DCL单例(双重检查锁定)。

4.懒汉模式双重校验锁

public class Singleton {

private static volatile Singleton instance = null;

private Singleton() {

}

public static Singleton getInstance() {

if(null == instance){

synchronized (Singleton.class) {

if(null == instance){

instance = new Singleton();

}

}

}

return instance;

}

}

代码中进行了两次if检查，这样就可以保证线程安全，初始化一次后，

后面再次访问时，if检查，直接return 实例化对象。volatile是1.5后

引入的，volatile关键字会屏蔽Java虚拟机所做的一些代码优化，会导

致系统运行效率降低，而更好的写法是使用静态内部类来实现单例！

5.静态内部类实现单例模式

public class Singleton {

private Singleton() {

}

public static final Singleton getInstance() {

return SingletonHolder.INSTANCE;

}

private static class SingletonHolder {

private static final Singleton INSTANCE = new Singleton();

}

}

和饿汉式类似，两者都是通过类装载机制来保证初始化实例

的时候只有一个线程，从而避免线程安全问题，饿汉式的

Singleton类被加载，就会实例化，而静态内部类这种，

当Singleton类被加载时，不会立即实例化，调用getInstance方法，

才会装载SingletonHolder类，从而完成Singleton的实例化。

6.枚举实现单例模式

public enum SingletonEnum {

INSTANCE;

private Singleton instance;

SingletonEnum() {

instance = new Singleton()

}

public Singleton getInstance() {

return instance;

}

}

访问方式：SingletonEnum.INSTANCE.method();

INSTANCE即为SingletonEnum类型的引用，得到它就可以调用

枚举中的方法。既避免了线程安全问题，还能防止反序列化

重新创建新的对象，但是失去了类的一些特性，没有延时加载，

推荐使用。

7.使用容器实现单例模式

public class SingletonManager {

private static Map objMap = new HashMap();

private Singleton() { }

public static void registerService(String key,Object instance) {

if(!objMap.containsKey(key)) {

objMap.put(key,instance);

}

}

public static Object getService(String key) {

return objMap.get(key);

}

}

将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象

对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使

用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用

户隐藏了具体实现，降低了耦合度。

优缺点

优点：保持类对象唯一性，对于频繁创建和销毁的对象可以提高性能。

缺点：扩展困难，单例的方法无法生成子类对象，要扩展的话基本要重写这个类。