设计模式之单例模式

设计模式

🌴 什么是设计模式？ 设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的；

🌴 简单地说，设计模式就是前人总结出来的，一个非常实用的设计套路；

单例模式

🌴 单例模式是校招中最常考的设计模式之一， 其存在的意义是防止一个全局使用的类频繁地创建与销毁，当您想控制实例数目，节省系统资源的时候就要使用单例模式，单例模式包括饿汉式和懒汉式；

🌴 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一； 它具有以下三个特点：

1、单例类只能有一个实例；

2、单例类必须自己创建自己的唯一实例；

3、单例类必须给所有其他对象提供这一实例；

饿汉式

🌴 饿汉式写法：

public class 饿汉式{
    //使用private定义一个构造函数，这样该类就不会被实例化（单例模式的本质）
    private 饿汉式(){}
    //创建饿汉式的一个实例化对象
    private static 饿汉式 instance = new 饿汉式();
    //用于获取唯一可用的对象
    private static 饿汉式 getInstance(){
        return instance;
    }
    //从下面的main函数中实例化对象
    public static void main(String[] args){
        //下面这样写不行，单例模式的用处就是不让你随便new对象
    	//饿汉式 instance = new 饿汉式();
        饿汉式 instance1 = 饿汉式.getInstance();
        饿汉式 instance2 = 饿汉式.getInstance();
        //若输出为true，则证明上面不是两个对象，而是一个对象
        System.out.println(instance1==instance2);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

🌴 从上面代码可以看出，当类加载而不是类调用的时候，就会产生对象实例化，所以将这种设计模式叫做饿汉式；

懒汉式-线程不安全版

public class 懒汉式{
    //一开始将实例化对象设为null或者不写；
    private static 懒汉式 instance = null;
    //使用private定义一个构造函数，这样该类就不会被实例化
    private 懒汉式(){}
    //用于获取唯一可用的对象
    public static 懒汉式 getInstance(){
        //懒汉式和饿汉式的区别之一
        if(instance == null){
            instance = new 懒汉式();
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

🌴 对比饿汉模式来看，当类被调用的时候才会实例化对象，更加节省空间；但是其中有一个最大的问题就是线程不安全；

🌴 为什么是线程不安全的？

☀️ 假设当线程1调用该线程并执行到if判断里面且还没有创建实例化对象的时候，时间片轮转到线程2，此时线程2也会进入if判断里（因为此时还没有创建对象），倘若线程2也在创建实例化对象之前用完了时间片，那么下一个线程同样有可能会进入if判断（时间足够的话），这样的话就可能会创建出三个对象（当时间片再次轮转的时候，不需要再进行if判断就可以创建对象了）；

懒汉式-多线程版

🌴 为了防止上述情况发生，我们可以通过加锁来解决；

🌴 这种方式能够在多线程中很好的工作，但是，由于加了锁所以效率很低；

class Singleton{
    private static Singleton instance = null;
    private Singleton(){}
    /*加了锁之后，一个线程进入后，另一个线程就无法进入(对于一个已经竞争到同步锁的线程，在还没有走出同步块的时候，即使时间片结束也不会释放锁)*/
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}
1
2
3
4
5
6
7
8
9
10
11

🌴 如何解决效率低下的问题？

懒汉式-多线程改进版（双重校验锁）

🌴 采用下面这种方式，安全且在多线程情况下可以保持高性能；

public class Singleton {  
    private Singleton (){} 
    //volatile防止出现空指针异常
    private volatile static Singleton instance;
    public static Singleton getSingleton() {
    //如果instance不为null，不需要抢占锁，直接返回对象
    if (instance == null) {  
        synchronized (Singleton.class) {  
            //再次判断instance为不为空
            if (instacne == null) {  
                instance = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

🌴 双重检查锁不仅实现了单例而且保证了性能；