java Singleton 几种方式解析转

概念：

在Java应用程序中，一个类Class只有一个实例存在.

单例模式属于对象创建型模式，其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点。对一些类来说，只有一个实例是很重要的，虽然系统中可以有许多打印机，但却只应该有一个打印机假脱机，只应该有一个文件系统和一个窗口管理器，一个数字滤波器只能有一个A/D转换器，一个会计系统只能专用于一个公司。怎样才能保证一个类只有一个实例并且这个实例易于被访问，一个全局变量使得一个对象可以被访问，但它不能防止你实例化多个对象，一个更好的方法是让类自身负责保存他的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法，这就是Singleton模式。

       实用性：在下面的情况下可以使用Singleton模式。

•  当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
•  当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

例如：一个产生随机数的例子，整个应用程序中只需要一个类的实例来产生随机数，客户端程序从类中获取这个实例，调用这个实例的方法nextInt()，公用的方法访问需要进行同步，这是单例模式需要解决的同步问题。

 

 

参与者：Singleton：定义一个Instance操作，允许客户访问它的唯一实例，Instance是一个类操作。可能负责创建自己的唯一实例。

协作关系：客户只能通过Singleton的Instance操作访问一个Singleton的实例。

使用Singleton模式有许多优点：

1.         对唯一实例的受控访问，

2.         缩小命名空间，

3.         允许对操作和表示的精化，

4.         允许可变数目的实例。

5.         比类操作更灵活。

运用：

1）系统资源，如文件路径，数据库链接，系统常量等

2）全局状态化类，类似AutomicInteger的使用

优缺点：

1）节省内存有利于垃圾回收

2）只能使用在特定的环境下,受限制于JVM和容器

     单例作用范围的前提是在一个ClassLoad下。所以像分布式应用EJB就要用其它的方式来解决单例问题。

Demo：

分别列出多种实现方式，各分析其优缺点

1）静态成员直接初始化，或者在静态代码块初始化都可以

Java代码

 

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

      该实现只要在一个ClassLoad下就会提供一个对象的单例。但是美中不足的是，不管该资源是否被请求，它都会创建一个对象，占用jvm内存。从lazy initialization思想出发，出现了下2的写法

2）根据lazy initialization思想，使用到时才初始化。

 

Java代码

 

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

 

       该实现方法加了同步锁，可以有效防止多线程在执行getInstance方法得到2个对象。

缺点：只有在第一次调用的时候，才会出现生成2个对象，才必须要求同步。而一旦singleton 不为null，系统依旧花费同步锁开销，有点得不偿失。

因此再改进出现写法3

3）在2的基础上改进，改进标准：尽量减少锁资源(主要体现在执行时间，所占内存等)

 

Java代码

 

class Singleton{  
        private Singleton(){}  
        private static Singleton singleton ;  
        public static Singleton getInstance(){  
            if(singleton==null)//1  
                synchronized(Singleton.class){//2  
                    singleton = new Singleton();//3  
                }  
            return singleton;         
        }     
    }  

这种写法减少了锁开销，但是在如下情况，却创建了2个对象：

a:线程1执行到1挂起，线程1认为singleton为null

b:线程2执行到1挂起，线程2认为singleton为null

c:线程1被唤醒执行synchronized块代码，走完创建了一个对象

d:线程2被唤醒执行synchronized块代码，走完创建了另一个对象

所以看出这种写法，并不完美。

4）为了解决3存在的问题，引入双重检查锁定

 

Java代码

  

 public static Singleton getInstance(){  
            if(singleton==null)//1  
                synchronized(Singleton.class){//2  
                    if(singleton==null)//3  
                        singleton = new Singleton();//4  
                }  
            return singleton;         
        }  

      在同步锁代码块内部，再判断一次对象是否为null，为null才创建对象。这种写法已经接近完美：

a:线程1执行到1，已经进入synchronized的时候，线程挂起，线程1占有Singleton.class资源锁；

b:线程2执行到1，当它准备synchronized块时，因为Singleton.class被占用，线程2阻塞；

c:线程1被唤醒，判断出对象为null，执行完创建一个对象

d:线程2被唤醒，判断出对象不为null，不执行创建语句

      如此分析，发现似乎没问题。

      但是实际上并不能保证它在单处理器或多处理器上正确运行；

      问题就出现在singleton = new Singleton()这一行代码。它可以简单的分成如下三个步骤：

mem= singleton();//1

instance = mem;//2

ctorSingleton(instance);//3

       这行代码先在内存开辟空间，赋给singleton的引用，然后执行new 初始化数据，但是注意初始化是要消耗时间。如果此时线程3在执行步骤1的时候，发现singleton 为非null，就直接返回，那么线程3返回的其实是一个没构造完成的对象。

      我们期望1,2,3 按照反序执行，但是实际jvm内存模型，并没有明确的有序指定。

      这归咎于java的平台的内存模型允许“无序写入”。

5）在4的基础上引入volatile

代码如下：

Java代码

class Singleton{  
        private Singleton(){}  
        private static volatile Singleton singleton ;  
        public static Singleton getInstance(){  
            if(singleton==null)//1  
                synchronized(Singleton.class){//2  
                    if(singleton==null)//3  
                        singleton = new Singleton();  
                }  
            return singleton;         
        }     
    }  

       Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。

而volatile使用时有明确的规定：

1.       对变量的写操作不依赖于当前值；
2.       该变量没有包含在具有其他变量的不变式中；

—— 只有在状态真正独立于程序内其他内容时才能使用 volatile。

但是5的写法，虽然理论上似乎可以解决无序写入问题。实际上并非如此。

（我个人觉得这里对volatile语法说的不够详细，想知道详细的可以看这篇转帖Java 理论与实践: 正确使用 Volatile 变量 ）

小结：

1）使用同步锁方法，内部锁存在不安全。

2）静态成员直接初始化。

转：http://nkliuliu.iteye.com/blog/980851