单例模式

今天看了一下单例模式，收获颇丰，以前都只是马虎地学一下，现在总结一下以便以后复习。

单例模式要满足一下条件：

1）拥有私有的构造方法，确保用户无法通过new直接实例它

2）拥有静态公有方法，以确保有一个实例被创建

3）一个静态的变量用来保存单实例的引用

下面是我总结的3种方式：

1）饿汉式

package com.tomwills.singleton;

/**
 * 单例模式1--饿汉式
 * @author-tomwills:2013-7-22
 *
 */

public class SingletonTest
{
    public static void main(String[] args)
    {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton == singleton2);
        
    }
}
class Singleton
{    
    /*
     * 一个静态的变量用来保存单实例的引用
     * static是为了让getInstance()可以访问
     * 静态方法只能访问静态变量
     */
    private static Singleton single = new Singleton();
    
    /*
     * 拥有私有的构造方法，确保用户无法通过new直接实例它
     */
    private Singleton(){
        
    }
    
    /*
     * 拥有静态公有方法，以确保有一个实例被创建
     * static保证了外部类可以通过类名直接调用该方法
     */
    public static Singleton getInstance()
    {
        return single;
    }
}

2)懒汉式

package com.tomwills.singleton;

/**
 * 单例模式2 懒汉式--线程安全，但效率低，
 * 因为很多情况下不需要线程同步
 * 
 * @author-tomwills:2013-7-22
 */

public class SingletonTest2 {

    public static void main(String[] args) {
        Singleton2 s = Singleton2.getInstance();
        Singleton2 s2 = Singleton2.getInstance();
        System.out.println(s == s2);
    }
}

 class Singleton2 {  
     private static Object object = new Object();
     private static Singleton2 instance; 
     
     private Singleton2 (){
         
     }
     
     /*
      * synchronized关键字 
      * 保证在同一时刻最多只有一个线程执行该段代码(线程安全)
      * 
      * synchronized代码块
      * 只会将块中代码同步，块外的可以被多个线程访问，提高开发效率
      * 若没有synchronized代码块，则线程不安全
      */
     public static Singleton2 getInstance() { 
         synchronized(object){            
             if (instance == null) {  
                    instance = new Singleton2();  
                 }  
                     return instance;
         }  
     }  
 } 

3）双重校验锁

package com.tomwills.singleton;

/**
 * 单例模式3 双重校验锁(Double-Checked Locking)
 * 是懒汉式的升级版
 * 
 * @author-tomwills:2013-7-22
 */

public class SingletonTest3 {

    public static void main(String[] args) {
        Singleton3 s = Singleton3.getInstance();
        Singleton3 s2 = Singleton3.getInstance();
        System.out.println(s == s2);
    }
}

 class Singleton3 {  
     
     private static Singleton3 instance; 
     
     private Singleton3 (){
         
     }
     
     /*
      * 先判断实例是否为空再加锁，而不用让线程每次都加锁
      */
     public static Singleton3 getInstance() {             
             if (instance == null) { 
                 synchronized(Singleton3.class){
                    instance = new Singleton3(); 
                    } 
                 }  
                     return instance;
         }    
 } 

 测试结果皆为：true