Java设计模式 - 单例模式

1.定义

确保一个类只有一个实例，并提供一个全局访问点！

2.常见的集中单例实现

2.1 饿汉式

/** 
 * 单例模式的实现：饿汉式,线程安全
 */  
public class SingletonTest {  

    // 定义一个私有的构造方法
    private SingletonTest() {  
    }  

    // 将自身的实例对象设置为一个属性,并加上Static和final修饰符
    private static final SingletonTest instance = new SingletonTest();  

    // 静态方法返回该类的实例
    public static SingletonTest getInstancei() {  
        return instance;  
    }  
}

2.2 懒汉式 

线程安全，可延迟加载，但由于JVM底层内部模型原型，偶尔会出现问题。

/**  
 * 单例模式最优方案
 * 线程安全，并且效率高  
 */  
public class SingletonTest { 

    // 定义私有构造方法
    private SingletonTest() { 
     
    }   
    //定义一个静态私有变量，使用volatile保证了多线程访问时instance变量的可见性，避免了instance初始化时其他变量属性还没赋值完时，被另外线程调用
    private static volatile SingletonTest instance;  

    //定义一个共有的静态方法，返回该类型实例
    public static SingletonTest getIstance() { 

        // 对象实例化时与否判断（不使用同步代码块，instance不等于null时，直接返回对象，提高运行效率）
        if (instance == null) {

            //同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建）
            synchronized (SingletonTest.class) {

                //未初始化，则初始instance变量
                if (instance == null) {
                    instance = new SingletonTest();   
                }   
            }   
        }   
        return instance;   
    }   
}

2.3 静态内部类方式

这种方式外部类没有static 属性，不会像饿汉一样立即加载对象。只有真正调用getInstance()才会加载静态内部类，加载时是线程安全的，兼并延时调用和并发高效调用。

/**
 * 静态内部类方式，线程安全，调用效率高，可以延时加载
 */
 public class Singleton {  
     private static class SingletonHolder {  
         private static final Singleton INSTANCE = new Singleton();  
     }  
     private Singleton (){}
     public static final Singleton getInstance() {  
         return SingletonHolder.INSTANCE;  
     }  
 }

 

 

2.4 使用枚举的单例模式

目前最为安全的实现单例的方法。通过内部静态enum的方法来实现，因为JVM会保证enum不能被反射并且构造器方法只执行一次。

避免了反射和反序列化的漏洞，但没有延时加载的效果。

/**
 * 使用枚举的单例模式
 * 线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用
 */
public class EnumSingleton{
    private EnumSingleton(){}
    public static EnumSingleton getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    
    private static enum Singleton{
        INSTANCE;
        
        private EnumSingleton singleton;

        //JVM会保证此方法绝对只调用一次
        private Singleton(){
            singleton = new EnumSingleton();
        }
        public EnumSingleton getInstance(){
            return singleton;
        }
    }
}

 

如何选用：

-单例对象 占用资源少，不需要延时加载，枚举 好于 饿汉

-单例对象 占用资源多，需要延时加载，静态内部类 好于 懒汉式