请用Java写一个Singleton出来

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; 　　}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。

一般认为第一种形式要更加安全些

能保证只有一个实例存在。
比如打印机程序，只有一台打印机，如果有多个用户连接并且打印，那打印机怎么工作，打印谁的呢？所以要用Singleton， 保证此时此刻只能有一个打印实例，当这个打印实例完成打印，把这个实例给别人用，一个一个来，不然就乱套了。

更详细的介绍，http://nkliuliu.iteye.com/blog/980851

 
 

  
  
概念：
  
  
在Java应用程序中，一个类Class只有一个实例存在
  
  
运用：
  
  
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;}     
}    
  
  
  
  
    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;            
    }        
}    
  
  
  
  
    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;            
    }        
}    
  
  
  
  
    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;            
    }    
  
  
  
  
    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;            
    }        
}    
  
  
  
  
    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使用时有明确的规定：
  
  
      对变量的写操作不依赖于当前值； 
      该变量没有包含在具有其他变量的不变式中； 
  
  
—— 只有在状态真正独立于程序内其他内容时才能使用 volatile。 
  
  
但是5的写法，虽然理论上似乎可以解决无序写入问题。实际上并非如此。
  
  
（我个人觉得这里对volatile语法说的不够详细，想知道详细的可以看这篇转帖Java 理论与实践: 正确使用 Volatile 变量 ）
  
  
小结：
  
  
1）使用同步锁方法，内部锁存在不安全。
  
  
2）静态成员直接初始化。