java 单例模式（5种实现方式）

单例模式简介

单例模式（Singleton Pattern）是java中最简单的设计模式之一，它是一个创建型模式。
单例模式确保某个类在任何情况下绝对只有一个实例，并提供了一个全局访问点来访问这个实例。

确保类在内存中只存在一个实例对象。

五种实现方式

1.懒汉式

特点：单例对象被使用的时候才初始化，避免了内存浪费

线程不安全：

 
public class SingleObject {
    
    private static SingleObject instance;

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        if(instance==null){
            instance=new SingleObject(); //调用时才实例化对象
        }
        return instance;
    }
}

这种方法实现了懒加载，但是却是线程不安全的，只能在单线程中使用，当有多个线程同时进入getInstance方法中的if判断中，若判断为null,就会创建多个实例对象。

线程安全：

为了解决线程不安全的情况，给getInstance方法加上关键字synchronized

public class SingleObject {
    
    private static SingleObject instance;

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    //获取唯一可用的对象
    public synchronized static SingleObject getInstance(){
        if(instance==null){
            instance=new SingleObject(); //调用时才实例化对象
        }
        return instance;
    }
}

这样写虽然解决了线程安全，但是当有多个线程想要调用的时候，每个线程都要等上一个线程完成后再执行，大大降低了效率。

2.饿汉式

特点：没有实现懒加载，在类加载的时候初始化，即在运行之前只是将打包的代码加载到内存的时候就初始化，会造成内存浪费，但是它是线程安全的，并且执行效率高。

public class SingleObject {
    //创建 SingleObject 的一个对象
    private static SingleObject instance=new SingleObject();

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        return instance;
    }
}

3.双检锁/双重校验锁（懒汉式的优化）

特点：在对象声明时添加关键字volatile，防止指令重排，如果不用volatile关键字，就会和线程不安全的情形一样，在if判断处有并发。
上面懒汉式的代码的执行效率低，在同步前判断一下是否实现了实例化，若是没有实例化就用同步方法new一个，否则就直接返回。

public class SingleObject {
    //使用volatile关键字防止指令重排
    private volatile static SingleObject instance;

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        if(instance==null){
            synchronized (SingleObject.class){
                if(instance==null){
                    instance=new SingleObject();
                }
            }
        }
        return instance;
    }
}

使用两重if的原因是若是多个线程同时进入了第一层if判断，第一个线程进入锁中一定是没有问题的，但是其他的线程再进入锁中不进行判断就会再次新建一个对象。

4.静态内部类

特点：该方法使用静态内部类创建对象，在调用时加载内部类，然后返回对象，使用JVM保证了装载的线程安全，并且能够保证懒加载。

public class SingleObject {
    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    //内部类 默认是不加载的
    private static final class SingleHodle{
        private static final SingleObject INSTANCE=new SingleObject();
    }

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        //返回之前一定会先加载内部类
        return SingleHodle.INSTANCE;
    }
}

静态内部类在外部类加载的时候不会实例化，在调用getInstance方法的时候，返回对象结构之间会加载内部类，从而实现了延迟加载。

5.枚举

特点：枚举就是饿汉式的单例模式在类加载时就初始化了。目前这种实现方式很少用，但是是最佳的单例模式的实现方式，它更简洁，而且支持序列化机制，绝对防止多次实例化。

public enum SingleObject {
    INSTANCE; //属性
    public void show(){
        System.out.println("this is method");
    }
}

注意：

前四种方式实现的单例模式都是可以通过反射和序列化破坏的。

扩展

解决反射方式破坏单例模式的问题：java 反射破坏单例模式以及解决方式
解决序列化方式破坏单例模式的问题：java 序列化破坏单例模式以及解决方式