设计模式一之单例模式

一、单例模式：

　　一个类在系统中只有一个实例。

　　要点：

• 私有的构造方法
• 指向自己实例的私有静态引用
• 以自己实例为返回值的静态的公有的方法

　　单例模式根据实例化对象时机的不同分为两种：

      1.1、饿汉式单例

        饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用

/**
 * 饿汉式单例
 */
public class SingletonEh {

    private SingletonEh() {}
    /**
     * 类初始化时加载，只加载一次，线程安全
     * 没有 延迟加载 的优势，如果该实例很大，会比较耗费资源。
     */
    private static final SingletonEh single = new SingletonEh();

    /**
     * 没有同步synchronized,调用效率高
     * @return
     */
    public static SingletonEh getInstance() {
        return single;
    }
}

　   1.2、懒汉式单例

　　而懒汉式在调用取得实例方法的时候才会实例化对象

/**
 * 懒汉式单例
 */
public class SingletonLh {

    private SingletonLh() {}
    /**
     * 类初始化时不加载
     */
    private static  SingletonLh single;

    /**
     * 同步synchronized,线程安全，调用效率低
     * @return
     */
    public static synchronized SingletonLh getInstance() {

        if(null==single){
            single=new SingletonLh();
        }
        return single;
    }
}

　　1.3、双重锁形式-

PS:我不用这个写法的

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

　　1.4、静态内部类形式

/**
 * 匿名内部类方式单例
 * 即有延迟加载的优势，又是线程安全的
 */
public class SingletonInner {

    /**
     *内部类持有单例对象
     */
    private static class SingletonHolder {
       private static final SingletonInner single = new SingletonInner();
    }

    private SingletonInner(){}

    /**
     * 调用的时候才会加载single且只加载一次,线程安全，调用效率高
     * @return
     */
    public static final SingletonInner getInstance() {
       return SingletonHolder.single;
    }


}