单例模式

标签：oid   对话框   汇编   develop   1.5   网站   推荐   jason   vol   

　　单例模式是一种最常见的设计模式。单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态。单例模式有多种实现方法，以下分别针对这些实现方法的优缺点进行详细说明。

第一种：饿汉式，线程安全

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

　　简单粗暴；适合在初始化时就要用到单例的情况；适合单例对象初始化占用内存小，快速在加载这个类的时候会马上创建此唯一的单件实例，JVM保证在任何线程访问instance之前就会创建完毕

第二种：懒汉式，线程不安全

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

　　当单例对象较为庞大时,不易提前初始化；避免了只要程序初始化时就会强制初始化单例对象的无脑行为；无法保证线程安全 

第三种：懒汉式，线程安全

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

第四种：饿汉式的变种，线程安全

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

第五种：静态内部类

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

　　这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第一种和第四种方式不同的是（很细微的差别）：第一种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第一和第四种方式就显得很合理。

 第六种：枚举方式

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}  

　　这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过

第七种：双重校验锁

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

　　这个是第二种方式的升级版，俗称双重检查锁定，详细介绍请查看：http://www.ibm.com/developerworks/cn/java/j-dcl.html。在JDK1.5之后，双重检查锁定才能够正常达到单例效果。加入了提前判空逻辑，这样会节省许多不必要的等待(如果不为null，直接返回就OK，不需要在被阻塞住必须等前一个线程释放锁)。这种写法其实也有一个极端危险的情况，问题就出现在这句代码的内部执行顺序上instance = new Singleton()。在JVM编译的过程中会出现指令重排的优化过程，这就会导致当 instance实际上还没初始化，就可能被分配了内存空间，也就是说会出现 instance !=null 但是又没初始化的情况，这样就会导致返回的 instance 不完整。我们来看看这个场景：假设线程一执行到instance = new Singleton()这句，这里看起来是一句话，但实际上它并不是一个原子操作（原子操作的意思就是这条语句要么就被执行完，要么就没有被执行过，不能出现执行了一半这种情形）。事实上高级语言里面非原子操作有很多，我们只要看看这句话被编译后在JVM执行的对应汇编代码就发现，这句话被编译成8条汇编指令，大致做了3件事情： 1.给Singleton的实例分配内存。 2.初始化Singleton的构造器 3.将instance对象指向分配的内存空间（注意到这步instance就非null了）。 但是，由于Java编译器允许处理器乱序执行（out-of-order），以及JDK1.5之前JMM（Java Memory Medel）中Cache、寄存器到主内存回写顺序的规定，上面的第二点和第三点的顺序是无法保证的，也就是说，执行顺序可能是1-2-3也可能是1-3-2，如果是后者，并且在3执行完毕、2未执行之前，被切换到线程二上，这时候instance因为已经在线程一内执行过了第三点，instance已经是非空了，所以线程二直接拿走instance，然后使用，然后顺理成章地报错，而且这种难以跟踪难以重现的错误估计调试上一星期都未必能找得出来。 DCL的写法来实现单例是很多技术书、教科书（包括基于JDK1.4以前版本的书籍）上推荐的写法，实际上是不完全正确的。的确在一些语言（譬如C语言）上DCL是可行的，取决于是否能保证2、3步的顺序。在JDK1.5之后，官方已经注意到这种问题，因此调整了JMM、具体化了volatile关键字，因此如果JDK是1.5或之后的版本，只需要将instance的定义改成 “private volatile static Singleton instance = null;” 就可以保证每次都去instance都从主内存读取，就可以使用DCL的写法来完成单例模式  

 第八种：CAS保证线程安全

public class Singleton {
    private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>(); 

    private Singleton() {}

    public static Singleton getInstance() {
        for (;;) {
            Singleton singleton = INSTANCE.get();
            if (null != singleton) {
                return singleton;
            }

            singleton = new Singleton();
            if (INSTANCE.compareAndSet(null, singleton)) {
                return singleton;
            }
        }
    }
}

　　CAS原理可以看这篇文章，这里简单总结一下。用CAS的好处在于不需要使用传统的锁机制来保证线程安全，CAS是一种基于忙等待的算法，依赖底层硬件的实现，相对于锁它没有线程切换和阻塞的额外消耗，可以支持较大的并行度。CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中)，会对CPU造成较大的执行开销  

参考网站：

1. http://cantellow.iteye.com/blog/838473

2. http://blog.csdn.net/jason0539/article/details/23297037/

3. http://blog.csdn.net/geekerhw/article/details/51851236

单例模式

标签：oid   对话框   汇编   develop   1.5   网站   推荐   jason   vol   

原文地址：http://www.cnblogs.com/suyk/p/7560225.html