java单例模式（六种）
概述
- 单例模式是23种设计模式中最常用的一种，属于设计模式中的创建型模式。
- 单例模式主要作用是让类在应用生命周期中只存在一个实例，避免类的重复创建，降低创建实例的资源消耗，提高性能
- 单例模式主要应用场景如数据库连接池、线程池、应用配置、spring bean，对了，还有你哦😜
饿汉式
顾名思义，饿汉式就跟你饿了一样，肯定想的是立马吃饭。而在代码里所表达的是立即创建实例。
优点：写法简单，易于理解，线程安全
缺点：立即加载，占用资源（当这个类越大，缺点越明显）
/**
* 饿汉式
* @author yz
* @version 1.0
* @date 2020/5/5 14:52
*/
public class HungrySingleton {
/**
* 好处：写法简单，易于理解，线程安全
* 缺点：立即加载，占用资源
*/
private static HungrySingleton hungrySingleton = new HungrySingleton();
private HungrySingleton() {
}
public static HungrySingleton getInstance() {
return hungrySingleton;
}
}懒汉式
懒汉式和饿汉式最大的区别是只有进行调用的时候才会进行创建，也就是懒加载，不会浪费系统资源，但是也会导致线程不安全，假如同时有两个线程同时调用了getInstance方法，当第一个线程正在new对象的时候，singletonLazy 还是等于null，这就导致了第二个线程可能会也进行new对象，导致出现两个对象
优点：延迟加载，节省资源
缺点：线程不安全
/**
* 懒汉式
* @author yz
* @version 1.0
* @date 2020/5/5 14:52
*/
public class LazySingleton {
/**
* 好处：延迟加载（懒加载）
* 缺点：线程不安全
*/
private static LazySingleton lazySingleton;
private LazySingleton() {
}
public static LazySingleton getInstance() {
if (lazySingleton== null) {
lazySingleton= new LazySingleton();
}
return lazySingleton;
}
}同步方法（懒汉式）
鉴于普通的懒汉式方法会导致线程不安全，那么就在getInstance上加上关键字synchronized，这样就保证了只有一个线程可以进入，保证了实例的单一，但是也会导致每次调用都会使用同步，而绝大多数情况下是不会产生并发的，所以导致了效率底下
/**
* 同步方法单例（懒汉式）
* @author yz
* @version 1.0
* @date 2020/5/5 14:52
*/
public class SynchronizedMethodSingleton {
/**
* 好处：延迟加载（懒加载），线程安全
* 缺点：调用效率太低
*/
private static SynchronizedMethodSingleton synchronizedMethodSingleton;
private SynchronizedMethodSingleton() {
}
public static synchronized SynchronizedMethodSingleton getInstance() {
if (synchronizedMethodSingleton == null) {
synchronizedMethodSingleton = new SynchronizedMethodSingleton();
}
return synchronizedMethodSingleton;
}
}双重锁（懒汉式）
双重锁模式是将synchronized加到了代码里，synchronized虽然加到了代码里，但是也需要在synchronized里再加一次if判断，如果两个线程同时调用getInstance方法，经过第一次if，实例可能为null，就会导致两个线程同时进入，第一个线程创建时，第二个线程等待，第一个线程创建实例完成后，第二个线程会再次创建，导致单例模式失败，所以在synchronized中加一个if，这样就避免了这种情况的发生。
volatile是用来防止重排序的
/**
* 双重锁（懒汉式）
* @author yz
* @version 1.0
* @date 2020/5/5 16:16
*/
public class DualLockSingleton {
private static volatile DualLockSingleton dualLockSingleton = null;
private DualLockSingleton() {
}
public static DualLockSingleton getInstance() {
if (dualLockSingleton == null) {
synchronized (DualLockSingleton.class) {
if (dualLockSingleton == null) {
dualLockSingleton = new DualLockSingleton();
}
}
}
return dualLockSingleton;
}
}静态内部类单例
静态内部类同时保证了延迟加载和线程安全，因为外部类和内部类没有直接关系，外部类加载时，并不会实例化静态类，只有调用时才会实例化内部类，同时因为类是静态的，所以保证了在内存中只有一个，所以不用担心线程安全问题
/**
* 静态内部类单例
* @author yz
* @version 1.0
* @date 2020/5/5 15:02
*/
public class StaticClassSingleton {
private static class InternalStaticClassSingleton {
private static StaticClassSingleton staticClassSingleton = new StaticClassSingleton();
}
private StaticClassSingleton() {}
public static StaticClassSingleton getInstance() {
return InternalStaticClassSingleton.staticClassSingleton;
}
}枚举单例
能防止反序列化重新创建新的对象，而且创建枚举默认是线程安全的，而且枚举中只有一个INSTANCE常量，jvm只会创建一个实例,枚举本质是就是实现了Enum接口的一个类（在枚举里没有定义抽象方法的时候），然后它将所有的值都在静态代码块里进行了初始化。所以枚举的单例是饿汉式，至于枚举如何防止序列华破坏，可以去看看readObject这个方法，你就会发现枚举单独处理了。至于防止反射攻击则更简单，newInstance这个方法里，直接判断如果类型是枚举，就会抛出异常
/**
* 枚举实现单例
* @author yz
* @version 1.0
* @date 2020/5/5 15:02
*/
public enum EnumSingleton {
INSTANCE;
public String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer age;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public EnumSingleton getInstance(){
return INSTANCE;
}
}单例模式的优点
1.确保所有对象都访问唯一实例
2.因为在类中创建，所以类可以灵活更改实例化过程
3.避免类的重复创建，降低创建实例的资源消耗，提高性能
单例模式的缺点
1.可扩展行比较差
2.如果对象长时间未调用，会被进行垃圾回收
