Java设计模式---单例模式

参考于 :

　　大话设计模式

　　java三百集---高淇

　　

　　讲在开头：如果需要懒加载，推荐使用静态内部类实现

　　　　　　　如果不需要懒加载，推荐使用枚举　　

1.单例模式的概念

　　保证一个类仅有一个实例，并提供一个访问它的全局访问点。

　　你可能会想，我在创建对象的时候，先判断是不是null，不是null就直接获得，是null就创建实例。

　　“生孩子还是不生孩子”应该是夫妻的责任，而不是我的责任。如果按照上面的想法，那么我就需要先判断一下才可以，这样“能不能生”就成了我的责任了哦。

　　我们把“生一个孩子”的责任交给类，我们只需要去获得就完事了。

　　

 2.第一种实现---饿汉式

　　JVM加载类的时候先实例化了

　　优点：JVM加载类是线程安全

　　缺点：不能懒加载

　　

package com.dingyu;

/**
 * 饿汉式单例模式 ，效率高
 * 线程安全，不需要synchronized关键字，但是不能懒加载
 * @author dingyu
 *
 */
public class Singleton01 {
    private static Singleton01 instance = new Singleton01();

    private Singleton01() {
        
    }
    
    public static Singleton01 getSingleton() {
        return instance;
    }
}

 3.第二种实现---懒汉式

　　调用方法的时候再去创建实例

　　优点：懒加载

　　缺点：需要同步（不同步，如果线程a，线程b同时调用getSingleton()，相当于new了两次），效率不高

　　

package com.dingyu;
/**
 * 懒汉式单例模式
 * 优点：懒加载
 * 缺点：需要同步
 * @author dingyu
 *
 */
public class Singleton02 {
    private static Singleton02 instance = null;

    private Singleton02() {

    }

    private static synchronized Singleton02 getSingleton() {
        if (instance == null)
            instance = new Singleton02();
        return instance;
    }
}

 4.第三种实现---双重锁定（尽量别用）

　　PS：已经搞懂，会出现指令重排序，简单来说：按理来说一个对象创建是先在堆内存中创建好对象再让引用去指向它，但编译器有的时候为了优化，会让引用指向那块内存，然后再分配

　　　　这个时候引用明明不为空，但内存里的对象还未分配好，就会出现问题。

　　　　解决方法：

　　　　private static Singleton03 instance = null;

　　　　变成

　　　　private volatile static  Singleton03 instance = null;

　　　　volatile 可以防止指令重排序

　　如果第一次获得就加锁，创建。其他的时候就直接返回就可以。

　　优点：效率高，可以懒加载

　　缺点： JVM内部的原因会出现不可预知的错误（本人还没去了解原因，如果有知道的可以告诉我下，感谢）

　　为什么要判断两次null，大话设计模式中解释了：如果线程a，线程b，通过突破了第一层null，线程a获得锁，线程b等着。a创建了个实例，释放锁，b获得锁，继续运行，如果没有第二层null，那么b仍然会创建一个实例，破坏单例模式。

package com.dingyu;

/**
 * 双重检测锁实现单例模式
 * 
 * @author dingyu
 *
 */
public class Singleton03 {
    private static Singleton03 instance = null;

    private Singleton03() {

    }

    public static Singleton03 getSingleton() {
        if (instance == null) {
            synchronized (Singleton03.class) {
                if (instance == null) {
                    instance = new Singleton03();
                }
            }
        }
        return instance;
    }
}

 5.第四种实现---静态内部类（推荐）

　　静态内部类是你用到他的时候，他才会加载，而且加载类的时候是线程安全的，不需要同步

　　优点：懒加载，效率高

package com.dingyu;
/**
 * 静态内部类实现单例模式
 * @author dingyu
 *
 */
public class Singleton04 {
    private Singleton04() {

    }

    private static class SingletonInnerClass {
        private static Singleton04 instance = new Singleton04();
    }

    public static Singleton04 getSingleton() {
        return SingletonInnerClass.instance;
    }
}

 

 6.第五种实现---枚举（推荐）

　　枚举很特殊，JVM帮我们实现的单例，天然是单例的

　　优点：效率高，反射破解不了

　　缺点：不能懒加载

　　

package com.dingyu;

/**
 * 枚举实现单例 枚举本来就是单例的
 * 
 * @author dingyu
 *
 */
public enum Singleton05 {
    INSTANCE;
}