单例模式

1. 概述

首先类的单例模式设计，就是采取一定的方法来保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）

2. 单例模式的八种方式

2.1 饿汉式（静态常量）

步骤如下：

1. 构造器私有化（为了防止能够new出一个对象）
2. 在类内部创建一个静态的对象实例
3. 使用一个getInstance()方法将静态实例对象返回 样例代码：

/**
 * 饿汉式，使用静态变量
 */
public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // 结果是true，说明这两者是同一个
    }
}

class Singleton {
    // 1. 构造器私有化，外部不能new
    private Singleton() {}

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

    // 3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点分析:

1. 优点：写法简单，在类装载的时候就完成了实例化，避免了线程同步问题
2. 缺点：在类装载的时候完成实例化，没有达到懒加载的目的，如果一直没有使用到这个实例，那么就会造成内存的浪费

这种方式基于ClassLoader机制避免了多线程的同步问题，但是我们希望在调用getInstance方法时才实例化，而不是类加载时就实例化（可能使用到该类的其他静态方法，那么也会进行类加载和实例化），也就是说这种方式没有达到懒加载的效果

所以这种方式可以使用，但是可能造成内存浪费

2.2 饿汉式（静态代码块）

方式2和方式1大致相同，只是是通过静态代码块的方式来实现

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);

    }
}

class Singleton {
    // 1. 构造器私有化，外部不能new
    private Singleton() {

    }

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

    static {
        instance = new Singleton();
    }

    // 3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

这种方式的优缺点和第一种是一样的，不再赘述

2.3 懒汉式（线程不安全）

步骤如下：

1. 构造方法私有化
2. 在类内部定义一个静态的对象实例
3. 提供一个公有的静态方法，当调用该方法时，在方法内部创建对象并返回

public class SingletonTest03 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // true
    }

}

class Singleton {
    // 注意这里没有初始化
    private static Singleton instance;

    // 构造方法私有化，防止外部new对象
    private Singleton() {
    }

    // 提供一个静态的公有方法，当使用带该方法时，在方法内部才去创建实例对象
    // 即懒汉式
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

优缺点分析：

1. 优点：起到了懒加载的效果，但是只能在单线程下使用
2. 如果在多线程下，一个线程进入了if (instance == null)判断语句时，还没来得及往下执行，另一个线程也通过了这个判断语句进入到了new对象的代码块，那么就会产生多个实例。所以在多线程环境下不可使用这种方式

在实际开发中，不要使用这种方式！！

2.4 懒汉式（线程安全，同步方法）

在创建对象的getInstance方法上添加synchronized关键字修饰，使方法线程安全

public class SingletonTest04 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // true

        new Thread(() -> {
            Singleton singleton3 = Singleton.getInstance();
            System.out.println(singleton3.hashCode());
        }).start();

        new Thread(() -> {
            Singleton singleton3 = Singleton.getInstance();
            System.out.println(singleton3.hashCode());
        }).start();
    }
}

class Singleton {
    // 注意这里没有初始化
    private static Singleton instance;

    // 构造方法私有化，防止外部new对象
    private Singleton() {
    }

    // 提供一个静态的公有方法，当使用带该方法时，在方法内部才去创建实例对象
    // 并且声明为synchronized，解决线程安全问题
    // 即懒汉式
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

优缺点分析：

1. 解决了线程不安全的问题
2. 效率太低了，每个线程在想要获得类的时候，执行getInstance()方法都要进行同步，而这个方法只执行一次实例化代码就够了，后面的线程想要或者该类的实例，直接return就好了，方法进行同步效率太低了！

所以这种 方法不推荐

2.5 懒汉式（线程安全，同步代码块）

在getInstance()内部定义同步代码块，以取代同步方法 样例代码：

public class SingletonTest05 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // true

        new Thread(() -> {
            Singleton singleton3 = Singleton.getInstance();
            System.out.println(singleton3.hashCode());
        }).start();

        new Thread(() -> {
            Singleton singleton3 = Singleton.getInstance();
            System.out.println(singleton3.hashCode());
        }).start();
    }
}

class Singleton {
    // 注意这里没有初始化
    private static Singleton instance;

    // 构造方法私有化，防止外部new对象
    private Singleton() {
    }

    // 提供一个静态的公有方法，当使用带该方法时，在方法内部才去创建实例对象
    // 并且添加synchronized代码块，试图解决线程安全问题
    // 即懒汉式
    public static  Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

注意：这种方式是错误的！！！！不能解决线程安全问题。因为两个线程都进入到了if判断语句，那还是会new出对象的。这种方法和懒汉方式1是一样的！

所以，实际开发中不能使用这种方式！ban掉

2.6 双重检查

对方式5进行了优化，在锁前后使用了双重检查

样例代码：

public class SingletonTest06 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // true

        new Thread(() -> {
            Singleton singleton3 = Singleton.getInstance();
            System.out.println(singleton3.hashCode());
        }).start();

        new Thread(() -> {
            Singleton singleton3 = Singleton.getInstance();
            System.out.println(singleton3.hashCode());
        }).start();
    }
}

class Singleton {
    // 注意这里没有初始化
    private static volatile Singleton instance;

    // 构造方法私有化，防止外部new对象
    private Singleton() {
    }

    // 提供一个静态的公有方法，当使用带该方法时，在方法内部才去创建实例对象
    // 并且添加synchronized代码块，在锁前后进行双重判断，解决线程安全问题
    // 而且后续线程的效率也不会受到印象，保证了效率
    // 即懒汉式
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

能够发现，即使两个线程都通过了判断语句，然后会遇到同步代码，这时只有一个线程能够执行，然后他new了一个对象，第二个线程又进行了一次判断，发现已经new过了， 所以不会再创建了。保证了线程安全。后续的线程进来，直接不会通过判断，所以也保证了效率！（这里方法不能声明为同步方法！）

这里instance变量还使用了volatile修饰，是为了让这个变量可见，用volatile修饰的变量，就会具有可见性。可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。

所以这种方式是推荐使用额单例设计模式

2.7 静态内部类

使用静态内部类，在内部类中定义一个实例化对象。然后在调用方法的时候，返回静态内部类中的实例化对象

样例代码：

public class SingletonTest07 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
    }
}

class Singleton {
    private static volatile Singleton instance;

    // 构造器私有化
    private Singleton() {}

    // 静态内部类，有一个静态属性Singleton
    // 静态内部类，在Singleton类被加载的时候，静态内部类不会被加载，所以也就不会实例化
    // 当方法使用到的时候，才会实例化对象并返回，确保了懒加载
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    // 提供一个静态的公有方法， 直接放回静态内部类中定义的实例对象
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

这里为什么使用静态内部类能够确保懒加载呢？

因为在Singleton类被装载的时候，静态内部类是不会被加载的，所以也就不会实例化，而是在需要实例化的时候，调用getInstance()方法，才会装载SingletonInstance类，从而完成Singleton的实例化

类的静态属性只会在第一次加载类的时候初始化，所以JVM帮我们保证了线程的安全性

所以这里避免了线程不安全，利用静态内部类特点实现延迟加载，效率高，推荐使用

2.8 枚举

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1 == instance2);
    }
}

enum Singleton {
    INSTANCE; // 属性

    public void sayOK() {
        System.out.println("ok...");
    }
}

推荐使用！ 不仅能够避免多线程同步问题，而且还能防止反序列化创建新的对象！

这里序列化和反序列化的问题的解释：

1. 类是能够被反序列化的，即使我们将构造方法设置为private，但是通过class文件我们还是能够new出一个新的对象
2. 枚举类不能被反序列化是Java的规定，Java规定枚举类序列化的时候是只将name输出，然后反序列化的时候根据这个name找到相对应的枚举类型，因此反序列化得到的实例跟之前的是同一个

3. 注意事项和细节说明

1. 单例模式确保了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统的性能
2. 当想实例化一个单例的时候，必须记住使用相应的获取对象的方法，而不是使用new
3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)