深入浅出设计模式学习笔记四：单例模式

单例模式，是设计模式中最简单的模式了，其基本定义是指确保一个类只有一个实例，并提供一个全局访问点。

 

为什么会需要单例模式的存在呢？

因为我们在实际的开发过程中，有些时候只需要一个对象，比如数据库连接池，线程池，缓存，日志对象，硬件设备的驱动程序的对象等，如果制造多个实例的话，会导致许多问题的产生，比如：程序的行为异常，资源过多浪费，结果不一致等。

 

单例模式的特点：

1、单例类在任何时刻都只有一个对象；

2、单例对象只能由单例类自己创建；

 

单例模式的类图：

单例模式常见的几种实现如下所示：

一、经典的单例模式的实现（懒汉式 线程不安全）

public class Singleton {
    
    private static Singleton uniqueInstance;
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        
        if (uniqueInstance == null) {
            
            uniqueInstance = new Singleton();         
        }        
        return uniqueInstance; 
    }  

}

 Singleton类拥有一个私有的静态变量uniqueInstance，私有的构造函数Singleton()，以及一个公共静态方法getInstance()，通过将构造函数设置私有的防止类在外部进行实例化（在这里我们忽略java的反射机制，因为java的反射机制能够实例化任意访问权限的构造函数，java的所有单例实现都会失效），Singleton的实例只能通过静态方法getInstance（）获取。

但是以上的单例的实现是线程不安全的,如果此时有两个以上的线程调用getInstance（）生成Singleton的实例时，会返回多个实例，违反了单例模式的设计初衷。

 

二、懒汉式 线程安全的

为了解决第一个实现线程不安全的问题，将getInstance（）方法变成同步，这样迫使每个线程在进入这个方法之前，需要先等候别的线程离开该方法，即不会有两个线程同时进入该方法。

public static synchronized Singleton getInstance(){
        
        if (uniqueInstance == null) { //1 
            
            uniqueInstance = new Singleton(); //2        
        }        
        return uniqueInstance; //3
    }  

但是同步会降低性能，而且，通过分析代码可以知道，只有在第一次执行该方法的时候，才会需要同步，因为真正需要同步的，只有//2处的代码，没有必要对后面的代码使用同步，一旦设置好uniqueInstance变量，就不再需要同步该方法了，但是由于该方法是synchronized的，除却第一次调用的时候，以后每次调用该方法的时候，同步都是一种累赘。

 

三、双重检查锁

利用双重检查锁，首先检查实例是否已经创建，如果未创建，才进行同步，这样，只有在第一次调用该方法会同步，保证了代码的性能和效率。

但是只适用于JDK1.5及以上的版本

public class Singleton{
    
    // volatile关键词确保当uniqueInstance被初始化为Singleton1的实例时，多个线程可以正确处理uniqueInstance
    private volatile static Singleton uniqueInstance; 
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        //判断实例是否存在，不存在的话进入同步代码块
        if (uniqueInstance == null) {
            //只有在第一次才会执行该代码块
            synchronized (Singleton.class) {
                //进入同步代码块后会再检查一次实例是否存在，如果不存在，才会创建实例
                if (uniqueInstance == null) {
                    
                    uniqueInstance = new Singleton();                 
                }            
            }            
        }        
        return uniqueInstance; 
    }  

}

四、饿汉式

基于类加载机制（稍后会重开一篇详细介绍）保证了线程安全，在类装载时就实例化。

public class Singleton{
    
    private static Singleton uniqueInstance = new Singleton();
    
    private Singleton(){};
    
    public static final Singleton getInstance() {  
        return uniqueInstance;  
    } 
} 

 

五、静态内部类

线程安全的，跟第四种方法的差别在于，第四种方法是只要Singleton被装载，就会实例化uniqueInstance，没有达到 lazy loading的效果，而这种方法，只有在调用getInstance()方法时，才会加载SingletonHolder类，进而实例化instance。

public class Singleton {
    //inner static class
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
        }
    //private and no-reference constructor method
    private Singleton(){};
    //public static method getInstance 
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
        } 
}

 

饿汉式和懒汉式的区别：

1、顾名思义，饿汉式是在Singleton类被装载时，就会实例化uniqueInstance，而懒汉式是在调用getInstance()方法时，才会去实例化uniqueInstance；

2、饿汉式是线程安全的，懒汉式本身是线程不安全的，可通过二，三，五三种方法使其变成线程安全的；

3、饿汉式是用“空间换时间”，而懒汉式是用“时间换空间”。

 

以静态内部类为例，实现一个使用单例模式的例子：

class Singleton {

    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
        }
    private String nameString = "";
    
    private Singleton(){};
    
    public String getNameString() {
        return nameString;
    }

    public void setNameString(String nameString) {
        this.nameString = nameString;
    } 
    
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }

    public void printInfo() {
        System.out.println("the name is " + nameString );
    } 
}

public class TestSingleton{
    
    public static void main(String[] args) {
        
        Singleton test1 = Singleton.getInstance();
        test1.setNameString("abc");
        Singleton test2 = Singleton.getInstance();
        test2.setNameString("123");
        
        test1.printInfo();
        test2.printInfo();
        
        if (test1 == test2) {
            System.out.println("the same singleton");
        }else {
            System.out.println("the different singleton");
        }    
    }    
}

运行结果：

 单例模式的优缺点：

优点：

1、确保所有的对象访问的都是同一个实例；

2、由于系统中只存在一个实例，因此可以节约资源；

3、避免对共享资源的多重占用；

4、简化复杂环境下的配置管理；

缺点：

1、单例类没有抽象层，因此不利于扩展；

2、不适用于变化的对象，如果同一个类的实例要在不同的场景发生变化，单例会引起数据错误，不能保存彼此的状态；

3、职责过重，在一定程度上违背了“单一职责原则”；