单例模式

单例模式：属于创建型设计模式，可以说是设计模式中使用最多，最简单的设计模式之一了。它的目的是保证在整个软件系统中，对于某个类确保只有单个实例对象，并且该类只提供了一种访问其唯一的对象方式(一般是静态方法)，可以直接访问，并不需要实例化该类的对象。转成大白话就是构建的整个软件系统里，整个类，自己实例化了一个对象，并向外提供了唯一的一种访问方式，确保了在整个系统里，只有单个实例对象，其他要访问它的类，只需要直接调用使用就好，无需再对它进行实例化。

本文来写一写关于单例模式的8种写法：

① 饿汉式(静态常量)[可用]

public class Singleton {
    //1.构造器私有化
    private Singleton() {
    }

    //2.在类的内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3.给外部暴露一个可以调用的静态的public方法,把实例对象return
    public static Singleton getInstance(){
        return instance;
    }
}
复制代码

测试验证单例效果：

public class Test {
    public static void main(String[] args) {
        Singleton a = Singleton.getInstance();
        Singleton b = Singleton.getInstance();
        System.out.println("是否是同一个对象："+(a == b));
        System.out.println("a的HashCode："+a.hashCode());
        System.out.println("b的HashCode："+b.hashCode());
    }
}
复制代码

运行结果：

优缺点

优点：写法简单粗暴，避免了线程同步问题
缺点：在类装载的时候就完成了实例化，没有达到懒加载的效果。
原因：此方式是基于classloder(类装载)机制避免了多线程同步问题，但是同时单例对象会在类装载时就完成实例化，如果从始至终没用过这个实例的话，会造成内存的浪费。导致类装载的原因有很多，虽然在单例模式中大多数都是调用getInstance方法，但是并不能确保没有其他的方式或者其他静态方法会导致类装载，所以这种单例写法并没有达到懒加载的效果。
小结：这种写法可用，不过有可能会造成内存的浪费

②饿汉式(静态代码块)[可用]

public class Singleton {
    //1.构造器私有化
    private Singleton() {
    }

    //2.在类的内部创建对象实例
    private static Singleton instance;

    static {//3.在静态代码块中创建单例对象
        instance = new Singleton();
    }

    //4.给外部暴露一个可以调用的静态的public方法,把实例对象return
    public static Singleton getInstance(){
        return instance;
    }
}
复制代码

测试验证单例效果：

public class Test {
    public static void main(String[] args) {
        System.out.println("-- 饿汉式(静态代码块) --");
        Singleton a = Singleton.getInstance();
        Singleton b = Singleton.getInstance();
        System.out.println("是否是同一个对象："+(a == b));
        System.out.println("a的HashCode："+a.hashCode());
        System.out.println("b的HashCode："+b.hashCode());
    }
}
复制代码

运行结果：

优缺点

这种方式跟”饿汉式(静态常量)”是类似的，只不过是把类的实例化过程放在了静态代码块中。在类装载的时候就执行了静态代码块的代码。所以优缺点同上。

小结：这种写法可用，不过有可能会造成内存的浪费

③懒汉式(线程不安全)

public class Singleton {

    //2.先声明
    private static Singleton singleton;

    //1.私有化构造方法
    private Singleton(){
    }

    //懒汉式
    //3.提供一个静态的public方法，当调用getInstance方法时才创建单例对象
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }

}
复制代码

测试验证单例效果：

public class Test {
    public static void main(String[] args) {
        System.out.println("-- 懒汉式(线程不安全) --");
        Singleton a = Singleton.getInstance();
        Singleton b = Singleton.getInstance();
        System.out.println("是否是同一个对象："+(a == b));
        System.out.println("a的HashCode："+a.hashCode());
        System.out.println("b的HashCode："+b.hashCode());
    }
}
复制代码

运行结果：

优缺点

优点：起到了 懒加载(lazy loading) 的效果
缺点：只能在单线程中使用，不能在多线程中使用。
原因：在多线程中，如果A线程执行到 if(singleton == null)但又还没来得及继续执行下面的代码，B线程也执行到了这句判空语句，这时就会产生多个实例。这样就 不再是单例模式 了
小结：在实际开发中，不要使用 这种方式

④懒汉式(线程安全,同步方法)

public class Singleton {

    //2.先声明
    private static Singleton singleton;

    //1.私有化构造方法
    private Singleton(){
    }

    //懒汉式
    //3.提供一个静态的public方法，加入了synchronized 解决线程安全问题当调用getInstance方法时才创建单例对象
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}
复制代码

测试验证单例效果：

public class Test {
    public static void main(String[] args) {
        System.out.println("-- 懒汉式(线程安全,同步方法) --");
        Singleton a = Singleton.getInstance();
        Singleton b = Singleton.getInstance();
        System.out.println("是否是同一个对象："+(a == b));
        System.out.println("a的HashCode："+a.hashCode());
        System.out.println("b的HashCode："+b.hashCode());
    }
}
复制代码

运行结果：

优缺点

优点：起到了 懒加载(lazy loading) 的效果，并且解决了线程不安全的问题
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率，极大多数情况下是不需要同步的。
原因：每个线程在想获得类的实例的时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获取该类实例，应该直接return就行了。这样导致了这段代码的执行效率低
小结：在实际开发中，不推荐使用 这种方式

⑤懒汉式(线程安全,同步代码块)

public class Singleton {

    //2.先声明
    private static Singleton singleton;

    //1.私有化构造方法
    private Singleton(){
    }

    //懒汉式
    //3.提供一个静态的public方法
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}
复制代码

测试验证单例效果：

public class Test {
    public static void main(String[] args) {
        System.out.println("-- 懒汉式(线程安全,同步代码块) --");
        Singleton a = Singleton.getInstance();
        Singleton b = Singleton.getInstance();
        System.out.println("是否是同一个对象："+(a == b));
        System.out.println("a的HashCode："+a.hashCode());
        System.out.println("b的HashCode："+b.hashCode());
    }
}
复制代码

运行结果：

优缺点

这种写法的本意是对 “懒汉式(线程安全,同步方法)” 的改进，因为同步方法的方式效率太低了，所以改为同步产生实例的代码块。但是这种方式并 不能起到线程同步的作用 跟 “懒汉式(线程不安全)” 遇到的问题是一样的，当有多个线程同时进入了判断语句if(singleton == null)，这时就会产生多个实例

小结：在实际开发中，不能使用这种方式

⑥双重检查(Double-Check) [推荐使用]

public class Singleton {

    //2.先声明 volatile 防止指令重排
    private static volatile Singleton singleton;

    //1.私有化构造方法
    private Singleton(){
    }

    //懒汉式
    //3.提供一个静态的public方法 加入双重检查的代码 ，解决线程安全问题和懒加载问题，生成单例对象
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class) {
                if(singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
复制代码

测试验证单例效果：

public class Test {
    public static void main(String[] args) {
        System.out.println("-- 双重检查 --");
        Singleton a = Singleton.getInstance();
        Singleton b = Singleton.getInstance();
        System.out.println("是否是同一个对象："+(a == b));
        System.out.println("a的HashCode："+a.hashCode());
        System.out.println("b的HashCode："+b.hashCode());
    }
}
复制代码

运行结果：

优缺点

优点：使用了两次if(singleton == null)检查，从而可以保证线程安全了，这样，实例化代码只用执行一次，后面再次访问时，只需判断第一次的 if(singleton == null)就可以直接return实例化对象，也避免了反复进行方法同步。
缺点：暂无明显缺点，只是实现方式相对于其他的方式稍微复杂一点。
小结：这种方式，线程安全；延迟加载；效率较高，在实际开发中，推荐使用 这种方式

⑦静态内部类[推荐使用]

public class Singleton {
    //1.私有化构造方法
    private Singleton(){
    }

    /**
     * 1.装载Singleton类时，静态内部类不会被装载。
     * 2.当调用到静态内部类的静态属性时，是线程安全的。
     */
    //静态内部类，该类中有一个静态属性 Singleton
    private static class SingletonInstance{
        private static Singleton SINGLETON = new Singleton();
    }

    //提供一个静态的public方法，直接返回SingletonInstance.SINGLETON
    public static Singleton getInstance(){
        return SingletonInstance.SINGLETON;
    }
}
复制代码

测试验证单例效果：

public class Test {
    public static void main(String[] args) {
        System.out.println("-- 静态内部类 --");
        Singleton a = Singleton.getInstance();
        Singleton b = Singleton.getInstance();
        System.out.println("是否是同一个对象："+(a == b));
        System.out.println("a的HashCode："+a.hashCode());
        System.out.println("b的HashCode："+b.hashCode());
    }
}
复制代码

运行结果：

优缺点

优点：这种方式利用了 classloader 机制来保证初始化实例时只有一个线程。静态内部类方式有两个特点：1、静态内部类SingletonInstance在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载,从而完成Singleton的实例化。2、类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
缺点：暂无明显缺点。
小结：此种方式避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高，实际开发中推荐使用

⑧枚举[推荐使用]

public enum Singleton{
    INSTNACE;
    //测试被调用的方法
    public void sayOk(){
        System.out.println("ok~");
    }
}
复制代码

测试验证单例效果：

public class Test {
    public static void main(String[] args) {
        System.out.println("-- 枚举方式 --");
        Singleton a = Singleton.INSTNACE;
        Singleton b = Singleton.INSTNACE;
        System.out.println("是否是同一个对象："+(a == b));
        System.out.println("a的HashCode："+a.hashCode());
        System.out.println("b的HashCode："+b.hashCode());
        a.sayOk();
        b.sayOk();
    }
}
复制代码