什么你还不会单例模式？看我花式实现饿汉式和懒汉式

设计模式：单例模式（关于饿汉式和懒汉式）

定义

• 单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

优缺点

优点

• 单例类只有一个实例，节省了内存资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能；
• 单例模式可以在系统设置全局的访问点，优化和共享数据，例如前面说的Web应用的页面计数器就可以用单例模式实现计数值的保存。

缺点

• 单例模式一般没有接口，扩展的话除了修改代码基本上没有其他途径。

类加载顺序

• 先执行父类的静态代码块和静态变量初始化，静态代码块和静态变量的执行顺序跟代码中出现的顺序有关。
• 执行子类的静态代码块和静态变量初始化。
• 执行父类的实例变量初始化
• 执行父类的构造函数
• 执行子类的实例变量初始化
• 执行子类的构造函数

同时类加载的过程是线程私有的，别的线程无法进入

如果类已经被加载：静态代码块和静态变量不在执行，再创建类对象时，只执行与实例相关的变量初始化和构造方法

Static关键字

一个类中如果有成员变量或者方法被static关键字修饰，那么该成员变量或方法将独立于该类的任何对象。它不依赖类特定的实例，被类的所有实例共享，只要这个类被加载，该成员变量或方法就可以通过类名去进行访问，它的作用用一句话来描述就是，不用创建对象就可以调用方法或者变量。

下面将列举几种单例模式的实现方式，其关键方法都是用static修饰的，并且，为了避免单例的类被频繁创建对象，我们可以用private的构造函数来确保单例类无法被外部实例化。

懒汉和饿汉模式

单例模式一般分为两种一种是饿汉式一种是懒汉式

饿汉式：在类加载时就完成了初始化，所以类加载比较慢，单获取对象的速度比较快

懒汉式：在类加载时不初始化，等到第一次被使用时才初始化

单例模式的写法重点

构造器私有化

​ 我们需要将构造方法私有化，而默认不写的话，是公有的构造方法，外部可以显式的调用来创建对象，我们的目的是让外部不能创建对象

提供获取实例的公有方法

​ 对外只提供一个公有的方法，用来获取实例，而这个实例是否是唯一的，单例的，由方法决定外部无需关心。

Java代码实现

饿汉式（可用）

public class Singleton {

    private final static Singleton INSTANCE = new Singleton();
    
    private Singleton(){}

    public static Singleton getInstance(){
        return INSTANCE;
    }

}

• 在类加载的时候就完成了实例化，避免了多线程的同步问题，但是因为在类加载就实例化了，没有达到懒加载的效果，如果该实例没有被使用，内存就浪费了

懒汉式

普通的懒汉式

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
    }

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

}

只有在方法第一次被访问时才会实例化，达到了懒加载的效果，对**getInstance()加了锁的处理，保证了同一时刻只能有一个线程访问并获得实例，**但是因为synchronized是修饰整个方法，每个线程访问都要进行同步，但是这个方法只执行一次实例化代码就够了，每次同步导致效率低下

双重检查懒汉式（推荐，可用）

public class Singleton {
	// volatile 让变量每次在使用的时候，都从主存中取。而不是从各个线程的“工作内存”
    private static volatile Singleton instance;

    private Singleton() {}

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

这种写法使用了两个if判断，并且同步的不是方法，而是代码块，效率较高。防止多次初始化对象

静态内部类

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }

}

• 这种静态内部类方式在Singleton类被装载时不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载Single通Instance类，从而完成对象的实例化
• 因为类的静态属性只会在第一次加载类的时候初始化，也就保证了SingletonInstance中的对象只会被实例化一次，并且这个过程也是线程安全的

枚举

public enum Singleton {
    INSTANCE;
}

• 线程安全：因为Java虚拟机在加载枚举类的时候会使用ClassLoader的方法，这个方法使用了同步代码块来保证线程安全。
• 避免反序列化破坏对象，因为枚举的反序列化并不通过反射实现。

最后

• 如果觉得看完有收获，希望能给我点个赞，这将会是我更新的最大动力，感谢各位的支持
• 欢迎各位关注我的公众号【java冢狐】，专注于java和计算机基础知识，保证让你看完有所收获，不信你打我
• 如果看完有不同的意见或者建议，欢迎多多评论一起交流。感谢各位的支持以及厚爱。