Java设计模式：你见过大厂是怎么玩单列模式的吗？

单例模式，是设计模式中最常见的模式之一，它是一种创建对象模式，用于产生一个对象的具体实例，可以确保系统中一个类只会产生一个实例。

单例模式

单例模式是Java中最简单的设计模式之一，属于创建型模式，它提供一种创建对象的最佳方式。

单例模式顾名思义就是单一的实例，涉及到一个单一的类，该类负责创建自己的对象，同时确保只有一个对象被创建，并且提供一种可以访问这个对象的方式，可以直接访问，不需要实例化该类的对象。

对于单列模式，在单例类的内部创建它的唯一实例，并通过静态方法getInstance()让客户端可以使用它的唯一实例；为了防止在外部对单例类实例化，将其构造函数的可见性设置为private，在单例类内部定义一个singleton类型的静态对象作为供外部共享访问的唯一实例。

单例模式的特点：

1.单例类只能有一个实例
2.这个实例必须由单例类自己创建
3.单例类需要提供给外界访问这个实例

单例模式的作用：

单例模式主要为了保证在Java应用程序中，一个类只有一个实例存在。
所有需要调用的地方都共享这一单例对象。实现方式：构造方法的重载，将构造方法设置为私有。

单例模式的结构

单例模式主要有以下角色：

• 单例类

只能创建一个实例的类

• 访问类

测试类，就是使用单例类的类

优缺点

优点

1. 对于频繁使用的对象，可以省去 new 操作花费的时间，尤其对那些重量级对象而言，削减了一笔非常客观的系统开销。
2. 由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，从而减轻 GC 压力，缩短 GC 停顿时间。

缺点

1. 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
2. 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
3. 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

常见写法

双重检查模式

public class Singleton {  
    private volatile static Singleton singleton;  //1:volatile修饰
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  //2:减少不要同步，优化性能
        synchronized (Singleton.class) {  // 3：同步，线程安全
        if (singleton == null) {  
            singleton = new Singleton();  //4：创建singleton 对象
        }  
        }  
    }  
    return singleton;  
    }  
}

推荐理由：

1. 延迟初始化。和懒汉模式一致，只有在初次调用静态方法getSingleton，才会初始化signleton实例。
2. 性能优化。同步会造成性能下降，在同步前通过判读singleton是否初始化，减少不必要的同步开销。
3. 线程安全。同步创建Singleton对象，同时注意到静态变量singleton使用volatile修饰。

为什么要使用volatile修饰？

虽然已经使用synchronized进行同步，但在第4步创建对象时，会有下面的伪代码：

memory=allocate(); //1：分配内存空间
ctorInstance();   //2:初始化对象
singleton=memory; //3:设置singleton指向刚排序的内存空间

当线程A在执行上面伪代码时，2和3可能会发生重排序，因为重排序并不影响运行结果，还可以提升性能，所以JVM是允许的。如果此时伪代码发生重排序，步骤变为1->3->2,线程A执行到第3步时，线程B调用getsingleton方法，在判断singleton==null时不为null，则返回singleton。但此时singleton并还没初始化完毕，线程B访问的将是个还没初始化完毕的对象。当声明对象的引用为volatile后，伪代码的2、3的重排序在多线程中将被禁止!

静态内部类模式

public class Singleton { 
    private Singleton(){
    }
      public static Singleton getSingleton(){  
        return Inner.instance;  
    }  
    private static class Inner {  
        private static final Singleton instance = new Singleton();  
    }  
} 

推荐理由：

1. 实现代码简洁。和双重检查单例对比，静态内部类单例实现代码真的是太简洁，又清晰明了。
2. 延迟初始化。调用getSingleton才初始化Singleton对象。
3. 线程安全。JVM在执行类的初始化阶段，会获得一个可以同步多个线程对同一个类的初始化的锁。

如何实现线程安全？

线程A和线程B同时试图获得Singleton对象的初始化锁，假设线程A获取到了，那么线程B一直等待初始化锁。线程A执行类初始化，就算双重检查模式中伪代码发生了重排序，也不会影响线程A的初始化结果。初始化完后，释放锁。线程B获得初始化锁，发现Singleton对象已经初始化完毕，释放锁，不进行初始化，获得Singleton对象。

在涉及到反射和序列化的单例中，建议使用下文的枚举类型模式。

其他类型的单例模式

懒汉模式(多线程不安全)

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

饿汉单例模式(多线程安全)

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

饿汉模式的线程安全同样通过类加载解决同步问题，但没有达到懒加载目的。（这里非常感谢之初z-chu的指正）

枚举单例模式(多线程安全)

public enum Singleton {
    INSTANCE;
    
    public void doSomething(){
        //todo doSomething
    }
}

在Joshua Bloch大神的《Effective Java》是推荐该方法的。虽然线程安全，在实际开发中，还没有被广泛采用。因为太过简洁以致于可读性较差，还没有在实战中被广泛推广。枚举单例模式的线程安全同样利用静态内部类中讲到类初始化锁。枚举单例模式能够在序列化和反射中保证实例的唯一性。

应用场景：

1.网站的计数器

2.应用程序的日志应用

3.数据库连接池

4.读取配置文件中的类

5.application

6.pask manager

总结

在实际工作中，单例的使用还是比较常见的，在几种实现方式中，双重检测机制、静态内部类、枚举方式都是比较推荐。

以上就是这篇文章的全部内容了，希望能对铁子们有帮助和收获。如果觉得文章有用，喜欢这篇文章的铁子们可以点点赞和关注，也可以分享出去让更多的人看见，一起努力一起进步！ 文章持续更新，也可以评论出你想看哪一块技术。铁子们的支持是我的动力，创作离不开铁子们的支持，在此先感谢大家！创作不易，各位的支持和认可，就是我创作的最大动力，我们下篇文章见。