Java 单例模式 Singleton

单例

单例的目的是确保一个类只有一个实例，并提供该实例的全局访问点。

• [类]

使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

懒汉式-线程不安全

懒汉式-单例，静态变量被延迟实例化，这样做的好处是节约资源，但是在多线程下，因为多线程同时进入if (uniqueInstance == null) ，并且此时 uniqueInstance 为 null，那么会有多个线程执行uniqueInstance = new Singleton(); 语句，这将导致实例化多次 uniqueInstance。

public class Singleton {
    private static Singleton unqueInstance = null;
    //私有构造函数
    private  Singleton(){

    }
    public static  Singleton getUnqueInstance(){
            if(unqueInstance==null){
                unqueInstance = new Singleton();
            }
            return unqueInstance;
    }
}

懒汉式-线程安全

线程不安全的原因是多个线程同时进入了共有静态函数中的if代码块里，所以只要在共有静态函数上加一个同步锁就可以防止这样的情况。

public class Singleton {
    private static Singleton unqueInstance = null;
    //私有构造函数
    private  Singleton(){

    }
    public static synchronized Singleton getUnqueInstance(){
            if(unqueInstance==null){
                unqueInstance = new Singleton();
            }
            return unqueInstance;
    }
}

但是其实这样笼统的修改会影响效率的问题，比如当unqueInstance不等于null的时候，应该直接返回，但是此时unqueInstance==null和unqueInstance!=null同时访问该方法,这会让线程阻塞时间过长，因此该方法有性能问题。

饿汉式-线程安全

public class Singleton {
    private static Singleton unqueInstance = new Singleton();
    //私有构造函数
    private  Singleton(){

    }
    public static  Singleton getUnqueInstance(){
            return unqueInstance;
    }
}

直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。

双重校验锁-线程安全

这个是对懒汉式线程安全的进一步改进，就像我们在之前的描述一样，线程不安全的原因是多个线程同时进入了共有静态函数中的if代码块里，我们只需要对if代码块加入同步锁，但是如果两个线程都执行了 if 语句，那么两个线程都会进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 uniqueInstance = new Singleton(); 这条语句，只是先后的问题，那么就会进行两次实例化。因此必须使用双重校验锁，也就是需要使用两个 if 语句。

public class Singleton {

    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

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

静态内部类实现

当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 getUniqueInstance() 方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。

这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

public class Singleton {

    private  Singleton(){
    }

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

    public static  Singleton getUniqueInstance(){
        return  SingletonHolder.INSTANCE;
    }
}

枚举实现

public enum Singleton {

    INSTANCE;

    private String objName;


    public String getObjName() {
        return objName;
    }


    public void setObjName(String objName) {
        this.objName = objName;
    }


    public static void main(String[] args) {

        // 单例测试
        Singleton firstSingleton = Singleton.INSTANCE;
        firstSingleton.setObjName("firstName");
        System.out.println(firstSingleton.getObjName());
        Singleton secondSingleton = Singleton.INSTANCE;
        secondSingleton.setObjName("secondName");
        System.out.println(firstSingleton.getObjName());
        System.out.println(secondSingleton.getObjName());

        // 反射获取实例测试
        try {
            Singleton[] enumConstants = Singleton.class.getEnumConstants();
            for (Singleton enumConstant : enumConstants) {
                System.out.println(enumConstant.getObjName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}