你真的了解单例模式么？

    单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。

 

一，单例模式的5中写法。（回字的四种写法，哈哈。）

    1，懒汉式

          （1）线程不安全的懒汉式

    public class Singleton {  
        private static Singleton instance;  
        private Singleton (){}  
      
        public static Singleton getInstance() {  
        //线程a↓ 线程b↓ 
        if (instance == null) {
       //线程a 创建一个对象 ，线程b 在这又会创建一次
            instance = new Singleton();  
        }  
        return instance;  
        }  
    }  

            初学单例模式常见的写法，懒加载，但是这种写法在实际中应用很少，因为会有线程安全问题。

 

          （2）线程安全的懒汉式

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

    ​    ​    ​用加锁的方式避免了线程安全问题，但是每一次都会判断锁，性能较低。

 

    2，饿汉式

          （1）恶汉 No1

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

    ​    ​    ​在类初始化的时候就已经创建了单例对象，导致类的初始化 不仅仅 只有调用 getInstance方法。调用静态方法或者静态变量等等。

所以没有 懒加载 的效果。

 

          （2）恶汉 No2

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

    ​    ​    ​和恶汉 No1 的效果一样。都是在类的初始化的时候去创建实例

 

    3，静态内部类

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

    ​这种方式我很喜欢，既保证了线程安全又实现了懒加载。因为当外部的类初始化的时候，不会导致内部类的初始化。只有当调用getInstance()的时候，才会创建这个单利实例。懒加载的优点：当这个instance是一个非常消耗资源的对象。我们可以让它延迟加载。在合适的时机才会创建对象。

 

    4，枚举

public enum Singleton {
	INSTANCE;
	public void doSomeThing() {
		//do someThing
	}
}

    ​这种也是非常推荐的方式，枚举是JDK1.5的特性，所以用的比较少。这种方式代码简单，并且保证的线程安全，还能防止反序列化创建新的对象，但是也同事失去了懒加载的特性。

 

    5，双重校验锁

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;
	}
}

    ​这种写法，这种方式像是“线程安全的懒汉模式的增强版”比较麻烦。并且在JDK1.5之前，由于instance= new Singleton();这句话不是原子操作，这句话分为三步

    1.给Singleton的实例分配内存。

    2.初始化Singleton的构造器

    3.将instance对象指向分配的内存空间（注意到这步instance就非null了）。

由于java编译器out-of-order（允许乱序执行）以及JMM中Cache、寄存器到主内存回写顺序的规定，上面的第二点和第三点的顺序是无法保证的。也就是 不一定是 1,2,3的顺序，如过是1,3,2. 在3执行完的时候，instance就非null了。此时切换到第二个线程，直接拿走这个实例使用，就会报错。但是在JDK1.5之后 这种模式才能达到正常的效果。

具体参见：http://blog.163.com/lby67224262@126/blog/static/1714153412011121104932660

 

二，你写的单例模式真的能用嘛？

 

下面我们考虑几种会破坏单例的情况，和解决办法

1，多个classloader 获得 不同的单例对象。举个例子，一些servlet容器可能用不同的classloder 去加载servlet，如果servlet引用了同一个单例类就会产生多个实例。

    如果想你的单例类能被同一个类加载器加载，那么就必须自己制定这个类加载器。代码如下

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

 

2，你的单例也有可能实现序列化接口，只要是实现了次接口，就有可能被反序列化。没一次反序列化创建对象，就会产生一个新的单例类的实例。解决办法如下。

public class Singleton implements java.io.Serializable {
	public static Singleton INSTANCE = new Singleton();
	protected Singleton() {
		// Exists only to thwart instantiation.
	}
	private Object readResolve() {
		return INSTANCE;
	}
}

 3，反射，还能访问private的构造方法。这样就可以创建很多对象。解决办法如下。

     

      反射时可以使用setAccessible方法来突破private的限制，我们需要做到第一点工作的同时，还需要在在 ReflectPermission("suppressAccessChecks") 权限下使用安全管理器（SecurityManager）的checkPermission方法来限制这种突破。一般来说，不会真的去做这些事情，都是通过应用服务器进行后台配置实现。具体请参考http://blog.csdn.net/yaerfeng/article/details/7103397

 

4，涉及到跨JVM（集群、远程EJB等）时 也会出现产生多个单例类的对象的问题。

      在一个多元 JVM 环境中，每个 JVM 拥有自己对于该单例对象的拷贝，这将导致很多问题，尤其是在对于资源的访问需要受限和加锁的集群的环境中。

      解决方式可以通过应用服务器提供的API 或者第三方的工具。详情参考http://blog.csdn.net/defonds/article/details/12705677