Java单例模式的几种实现

转载请注明原文地址：

一：静态内部类实现单例模式

　　原理：通过一个静态内部类定义一个静态变量来持有当前类实例，在类加载时就创建好，在使用时获取。

　　缺点：无法做到延迟创建对象，在类加载时进行创建会导致初始化时间变长。

public class SingletonInner {
    private static class Holder {
        private static SingletonInner singleton = new SingletonInner();
    }
 
    private SingletonInner(){}
 
    public static SingletonInner getSingleton(){
        return Holder.singleton;
    }

二：饿汉模式

　　原理：创建好一个静态变量，每次要用时直接返回。

　　缺点：无法做到延迟创建对象，在类加载时进行创建会导致初始化时间变长。

public class SingletonHungry {
 
    private static SingletonHungry instance = new SingletonHungry();
 
    private SingletonHungry() {
    }
 
    public static SingletonHungry getInstance() {
        return instance;
    }

三：懒汉模式

　　原理：延迟创建，在第一次用时才创建，之后每次用到就返回创建好的。

　　缺点：由于synchronized的存在，多线程时效率很低。

public class SingletonLazy {
 
    private static volatile SingletonLazy instance;
 
    private SingletonLazy() {
    }
 
    public static synchronized SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }

四：双重校验锁懒汉模式

　　原理：在getSingleton()方法中，进行两次null检查。这样可以极大提升并发度，进而提升性能。

public class Singleton {
    private static volatile Singleton singleton = null;//使用valatile，使该变量能被所有线程可见
 
    private Singleton(){}
 
    public static Singleton getSingleton(){
        if(singleton == null){
            synchronized (Singleton.class){//初始化时，加锁创建
                if(singleton == null){//为避免在加锁过程中被其他线程创建了，再作一次非空校验
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }    

五：上述4种方式实现单例模式的缺点