Java设计模式之单例设计模式

单例设计模式：

保证一个类在内存中只有一个实例对象（即一个对象服务所有请求）

使用情况：

1.对象越多，越难管理，控制实例产生的数量，可以节约资源

2.通过线程同步控制资源的访问

应用场景：

线程池、日志对象、缓存、对话框、打印机、显卡的驱动程序对象常被设计成单例

今天整理了六种常见实现单例模式的方法：

一：饿汉单例设计模式（类加载时就创建类的对象，若后面不使用则浪费内存）

步骤：

1.私有化构造函数（不能让别人new对象）

private Single(){}

2.申明本类的引用类型变量，并且使用该变量指向本类对象

private static Single s = new Single();

3.提供一个公共静态的方法获取本类的对象

public static Single getInstance(){
    return s;
}

这样一个单例就创建成功了，最后获取实例对象

Single s = Single.getInstance();

优点：写起来比较简单，不存在多线程重复初始化问题，也避免了synchronized所造成的性能问题。

缺点：当类被加载的时候，会初始化static的s实例，静态变量被创建并分配内存空间，不管你有没有用到这个实例，一直到类被卸载之前，这个实例会一直占着内存，因此在这种情况下会耗费内存。

二：懒汉单例设计模式（线程不安全）

步骤：

1.私有化构造函数（不能让别人new对象）

private Single(){}

2.申明本类的引用类型变量，但是不要创建对象

private static Single s2;

3.提供一个公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类对象，如果已经创建了，那么直接返回对象即可，若还未创建则先创建再返回该对象即可。

public static Single2 getInstance(){
    if(s2==null){
        s2=new Single2();
      }
        return s2;
}

缺点：多线程并发情况下，可能造成重复初始化问题。

以上两种方法推荐使用：饿汉单例设计模式，因为目前懒汉设计模式会存在线程安全问题，目前还不能保证一个类在内存中只有一个对象（多线程不能正常工作）

三：懒汉单例设计模式（线程安全，同步，效率低，一般情况下无需用同步）

1、2步同上

private Single(){}
private static Single s3;

3.使用synchronized关键字避免多线程访问时，可能造成重复初始化问题.

public static synchronized Single3 getInstance(){
    if(s3==null){
        s3=new Single3();
    }
        return s3;
}

方法三为方法二的简单优化

优点：使用synchronized关键字避免多线程访问时，出现多个s3实例。

缺点：同步方法频繁调用时，影响效率。

四：双重检验锁

public class Singleton4 {  
    // 定义一个私有构造方法  
    private Singleton4 (){}  
   //定义一个静态私有变量(不初始化，不使用final关键字，使用volatile保证了多线程访问时s4变量的可见性，避免了s4初始化时其他变量属性还没赋值完时，被另外线程调用)
    private volatile static Singleton s4;
    //提供一个公共静态的方法获取本类的对象,这里不同步
    public static Singleton4 getInstance() {  
    if (s4 == null) {  
        //此时开始同步
        synchronized (Singleton4.class) { 
            if (s4== null) {  
                s4= new Singleton4 ();  
            }  
        }  
    }  
    return s4;  
    }  
}  

第一次校验并不是线程安全的，也就是说可能有多个线程同时得到s4为null的结果，接下来的同步代码块保证了同一时间只有一个线程进入，而第一个进入的线程会创建对象，等其他线程再进入时对象已创建就不会继续创建。

这是一个很巧妙的方式，如果对整个方法同步，所有获取单例的线程都要排队，但实际上只需要对创建过程同步来保证"单例"，多个线程不管是否已经有单例可以同时去请求。

方法四为单例模式的最佳实现：不占内存，效率高，线程安全，多线程操作原子性。

五：静态内部类

public class Single5{
    private static class SingleInner{
        private static final Single5 INSTANCE = new Single5();
    }
    private Single5(){}
    public static Single5 getInstance(){
        return SingleInner.INSTANCE;
    }
}

与第一种饿汉式类似，使用了静态初始化器classloder机制保证初始化实例的时候只有一个线程，但是第一种饿汉式类被加载时就会实例化，而这种类被加载时不一定实例化，只有在调用getInstance方法时，才会调用内部类SingleInner，从而进行实例化，这样处理比第一种显得合理。

六：枚举

public enum Single6 {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
} 

这种方式是Effective Java作者Joshua Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，不过，enum是在1.5中才加入，实际开发中很少见。

参考链接：
https://www.cnblogs.com/kuoAT/p/6725808.html
http://www.cnblogs.com/yinxiaoqiexuxing/p/5605338.html
原文作者技术博客：https://www.jianshu.com/u/ac4daaeecdfe
95后前端妹子一枚，爱阅读，爱交友，将工作中遇到的问题记录在这里，希望给每一个看到的你能带来一点帮助。
欢迎留言交流。