单例模式总结

饿汉式单例：

优点：线程安全，使用时没有延迟

缺点：启动时就创建了实例，启动慢，可能造成资源浪费

public class Singleton1{
    private Singleton1(){}
    private static Singleton1 mSingleton1 = new Singleton1();

    public static Singleton1 getInstance(){
        return mSingleton1;
    }

    public static void main(String args[]){
        System.out.println("------");
        Singleton1.getInstance();
    }

}

懒汉式单例：

• ​ 线程不安全：（使用与单线程环境）

优点：懒加载，启动快，资源占用小，使用时才实例化，无锁

缺点：非线程安全

public class Singleton1{
    private Singleton1(){}
    
    private static Singleton1 mSingleton1;

    public Singleton1 getInstance(){
        if(mSingleton1 == null){
            mSingleton1 = new Singleton1();
        }
        return mSingleton1;
    }

}

• ​ 线程安全：（适用于多线程，但是效率不高）

优点：懒加载，启动快，资源占用小，使用时才实例化，有锁

缺点：synchronized为独占排他锁，并发性能差。

每次调用getInstance时候都需要进行同步，造成不必要的同步开销，

public class Singleton1{

    private Singleton1(){}
    
    private static Singleton1 mSingleton1;

    public static synchronized Singleton1 getInstance(){
        if(mSingleton1 == null){
            mSingleton1 = new Singleton1();
        }
        return mSingleton1;
    }

}

• 双重检查加锁（DCL）

缺点：首次加载反应稍慢，在某些情况下存在DCL失效

public class Singleton1{

    private Singleton1(){}
    //用到了volatile关键字
    //防止JVM的指令重排，造成指令顺序有所变化，
    //指令重排后可能代码还未初始化，但是被调用，造成空指针问题
    //如果此时线程B抢占cpu资源，执行第一个if判断的记过是false
    //从而会返回一个没有初始化完成的instance对象。
    private volatile static Singleton1 mSingleton1;

    public static synchronized Singleton1 getInstance(){
        //第一次防止不必要的同步
        if(mSingleton1 == null){
            synchronized(Singleton1.class){
                //第二次为null时才创建实例
                if(mSingleton1 = null){
                    mSingleton1 = new Singleton1();
                }
            }
            
        }
        return mSingleton1;
    }

}

静态内部类方式的单例：

静态内部类不会在Singleton1加载时一起加载，只有第一次调用getInstance方法是时候，才会初始化mSingleton1，通过虚拟机来控制静态内部类的加载，防止被多次加载

public class Singleton1{

    private Singleton1(){}
    
    private static class InnerHolder{
        private static final Singleton1 mSingleton1 = new Singleton1();
    }

    public Singleton1 getInstance(){
        return InnerHolder.mSingleton1;
    }

}

枚举实现单例：

实现简单，线程安全，无法进行懒加载

public enum Singleton {
    INSTANCE;
}

// 定义单例模式中需要完成的代码逻辑
public interface MySingleton {
    void doSomething();
}

public enum Singleton implements MySingleton {
    INSTANCE {
        @Override
        public void doSomething() {
            System.out.println("complete singleton");
        }
    };

    public static MySingleton getInstance() {
        return Singleton.INSTANCE;
    }
}

泛型实现单例：

import java.util.HashMap;
import java.util.Map;

public class SingleTonParent{
    private static Map<Class<? extends SingleTonParent>, SingleTonParent> INSTANCES_MAP = new HashMap<>();

    public synchronized static <E extends SingleTonParent> SingleTonParent getInstance(Class<E> instanceClass) throws Exception {
        if(INSTANCES_MAP.containsKey(instanceClass)){
            return INSTANCES_MAP.get(instanceClass);
        } else {
            E instance = instanceClass.newInstance();
            INSTANCES_MAP.put(instanceClass, instance);
            return instance;
        }
    }

    protected SingleTonParent(){
    }
}
//继承泛型父类
public class Test extends SingleTonParent{}
//调用方法
Test test = (Test)SingleTonParent.getInstance(Test.class);