Java中各种单例模式

写在前面

俗话说的好，不会写单例模式的程序员不是好程序员。同时单例模式在面试中也经常提及，有些公司甚至需要手撕单例模式，更有甚者，需要写出4种以上的单例模式，下面，我们就写几种单例模式。

在写之前，先看看什么是单例：
单例类在一个程序中只能有一个实例，这个类负责创建自己的对象，并确保只有一个对象被创建
代码要点：

• 构造器私有化
• 持有该类的属性
• 对外提供获取实例的静态方法

饿汉式

顾名思义，就是他很饿，一上来就new出来这个对象，将这个对象加载。
优点：类加载成功时，类静态属性就会被初始化，没有延迟。没有加锁，执行效率高。线程安全。
缺点：不管你要不要都会直接创建一个对象，会消耗一定的内存，可能会造成垃圾。对于反射和反序列化，他是不安全的。

//饿汉式单例模式
public class Hungry {
    private Hungry(){
        //私有化构造器，则对象不能通过外界的构造方法进行创建
    }
    //写一个当前类的实例属性
    private static Hungry instance = new  Hungry();

    //对外提供一个公有的对外获取当前对象的方法
    public static Hungry getInstance(){
        return instance;
    }
}

对于反序列化不安全，可以重写readResolve方法。

静态内部类式

//静态内部类单例模式
public class Singleton2 {
    private Singleton2(){
        //构造器私有化
    }

    private static class SingletonHolder{
        private static Singleton2 instance = new Singleton2();
    }

    public Singleton2 getInstance(){
       return  SingletonHolder.instance;
    }
}

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化instance，故而不占内存。这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。对于反射来说，禁止了反射，但对反序列化不安全(重写readResolve方法使得对反序列化安全)。

枚举式

枚举式被很多人称为最佳的单例实现模式，它线程安全，对于反射和反序列化来说，也是安全的。而且写法简单。

单元素的枚举类型已经成为实现Singleton的最佳方法
                      – 《effective java》

public enum Singleton3 {
    INSTANCE;

    public Singleton3 getInstance(){
        return INSTANCE;
    }
}

对于枚举式来说，它线程安全，支持序列化，反序列化安全，防止反射攻击。

懒汉式

关键在“懒”字上，代表的是延迟初始化。

//懒汉式单例模式
public class Singleton4 {

    //持有一个当前对象的属性，不初始化
    private static Singleton4 instance;

    private Singleton4(){
        //构造器私有化
    }

    //对外暴露此属性的公有方法
    public static Singleton4 getInstance(){
        if (instance==null){
            instance = new Singleton4();
        }
        return instance;
    }
}

懒汉式是线程不安全的，问题出在了getInstance方法上，如果线程A先进行判断，判断出instance为空，还没有初始化静态属性，而此时，线程A的时间片用完，线程B进入判断，由于还没有初始化，则B就会初始化类静态属性，之后A线程还会初始化一个。解决办法：在getInstance方法上加一个synchronized 关键字，也可以在方法体内部加一个synchronized代码块。但是效率很低，由此提出一种双检索DCL(double check lock)的方式。

双重检锁方式（DCL）

双重检锁是什么呢：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

//DCL单例模式
public class Singleton5 {
    //持有一个当前对象的属性，不初始化
    //volatile保证可见性，禁止指令重排
    private volatile static Singleton5 instance;
    private Singleton5(){
        //构造器私有化
    }
    //对外暴露此属性的公有方法
    public static Singleton5 getInstance(){
        if (instance == null){//先检查实例是否存在，如果不存在才进入下面的同步块
            synchronized (Singleton5.class){//同步块，线程安全的创建实例
                if (instance == null){ //再次检查实例是否存在，如果不存在才真的创建实例
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

这种实现方式既可使实现线程安全的创建实例，又不会对性能造成太大的影响，它只是在第一次创建实例的时候同步，以后就不需要同步了，从而加快运行速度。

ThreadLocal单例模式

//ThreadLocal实现单例
public class Singleton6 {
    private static Singleton6 instance;
    private Singleton6(){}//私有化构造器

    private static final ThreadLocal<Singleton6> threadLocalSingleton = new ThreadLocal<Singleton6>(){
        @Override//重写初始化方法
        protected Singleton6 initialValue(){
            return new Singleton6();
        }
    };
    //对外提供公有方法
    public Singleton6 getInstance(){
        return threadLocalSingleton.get();
    }
}

这种方式不加锁，以空间换时间，为每个线程提供变量的独立副本，可以保证各自线程中是单例的，但是不同线程之间不保证。
主要应用场景是：数据源动态路由。

CAS实现单例

import java.util.concurrent.atomic.AtomicReference;

//CAS实现单例模式
public class Singleton7 {

    /**
     * 利用AtomicReference
     */
    private static final AtomicReference<Singleton7> INSTANCE = new AtomicReference<Singleton7>();


    //私有化
    private Singleton7() {
    }


    //用CAS确保线程安全
    public static final Singleton7 getInstance() {
        for (; ; ) {
            Singleton7 current = INSTANCE.get();
            if (current != null) {
                return current;
            }
            current = new Singleton7();
            if (INSTANCE.compareAndSet(null, current)) {
                return current;
            }
        }
    }
}

无锁乐观策略，线程安全。

注册登记式

每使用一次，都往一个固定的容器中去注册并且将使用过的对象进行缓存，下次去取对象的时候，就直接从缓存中取值，以保证每次获取的对象都是同一个对象，IOC的单例模式，就是典型的注册登记式单例。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

//注册登记式
public class Singleton8 {
    private Singleton8(){}
    //登记簿，用来存放所有登记的实例
    private static Map<String,Object> map = new ConcurrentHashMap<String,Object>();

    public static Object getInstance(String className) {
        if (!map.containsKey(className)) {
            Object obj = null;
            try {
                obj = Class.forName(className).newInstance();
                map.put(className, obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return obj;
        } else {
            return map.get(className);
        }
    }
}

登记式实际对一组单例模式进行的维护，主要是在数量上的扩展，通过map我们把单例存进去，这样在调用时，先判断该单例是否已经创建，是的话直接返回，不是的话创建一个登记到map中，再返回。