单例模式

1单例模式

---

1.1饿汉式单例

单例类在整个程序中只能有一个实例，这个类负责创建自己的对象，并确保只有一个对象被创建。

全局使用的类、会消耗很多系统资源的类，需要写成单例。

代码实现要点

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

缺点

1. 如果我们没有用到单例的对象，容易造成资源浪费；
2. 对于反射和反序列化是不安全的；（为了防止反序列化，我们可以写一个readResolve()方法,但是我们无法防止反射）

/**
 * 最简单的饿汉式
 * 通过类加载机制，线程安全
 */
public class Singleton1 implements Serializable {
    /**
     *  写一个当前类的实例属性
     */
    private static Singleton1 instance = new Singleton1();
    /**
     * 私有化构造器之后，对象不能通过外界的构造方法进行创建
     */
    private Singleton1(){}

    /**
     * 对外提供一个获取当前对象的方法
     */
    public static Singleton1 getInstance(){
        return instance;
    }
    
    private Singleton1 readResolve(){
        return instance;
    }
}

1.2登记式单例

默认的登记式单例

/*登记式单例模式*/
public class Singleton2 {
    /*当我们使用Singleton2的其他静态方法时是不会调用SingletonHolder加载
    * 不会消耗系统资源*/
    private static class SingletonHolder{
        private static Singleton2 instance = new Singleton2();
    }

    private Singleton2(){
        System.out.println("Singleton2 loaded");
    }

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

增强版的登记式单例

/*登记式单例模式*/
public class Singleton2 {
    private static class SingletonHolder{
        private static Singleton2 instance = new Singleton2();
    }
    private Singleton2(){
        System.out.println("Singleton2 loaded");
        /*
        当我们用正常调用getInstance()创建对象时没有任何问题，不会抛出异常
        但是当我们用反射创建对象，由于类已经被加载到内存中了，所以instance必然不为空，所以下面的判断异常，程序停止
        */
        if(SingletonHolder.instance!=null){
            throw new IllegalStateException();
        }
    }
    public static Singleton2 getInstance(){
        return SingletonHolder.instance;
    }
}

1.3枚举式单例

/*
枚举类没有构造方法，所以无法通过反射创建对象，所以天生自带防止反射攻击
枚举类也可以防止反序列化(这点我不知道原因)
单例如果需要继承的话，枚举类就不太适合了
*/
public enum Singleton3 {
    INSTANCE{
        @Override
        protected void doSomething() {
            System.out.println("doSomething");
        }
    };

    protected abstract void doSomething();
}

1.4懒汉式单例

/*懒汉式单例，在第一次使用到的时候才去加载*/
public class Singleton4 {
    private static Singleton4 instance=null;//持有一个当前对象的属性，懒汉式时不初始化的
    private Singleton4(){}
    public static Singleton4 getInstance(){
        if(instance == null){
            //这个地方不是线程安全的，可能会有多个线程在这里创建Singleton4对象
            instance = new Singleton4();
        }
        return instance;
    }
}

增强型懒汉式单例

双检锁型懒汉式单例

/*增增强型懒汉式单例 双检锁*/
public class Singleton6 {
    private static /*volatile*/ Singleton6 instance=null;
    private Singleton6(){}

    public static Singleton6 getInstance(){
        if(instance==null){
            synchronized (Singleton6.class) {
                if (instance == null) {
                    instance = new Singleton6();
                }
            }
        }
        return instance;
    }
}

面试官出招：双检锁型的懒汉式单例是否是100%正确的呢？

我：我哪知道，当然不是100%咯，因为有**指令重排**。

instance = new Singleton6();会执行以下操作：

1. 分配对象内存空间
2. 初始化对象
3. instance指向1中分配的内存空间

在某些编译器上，可能出现指令重排：

1. 分配对象内存空间
2. instance指向1中分配的空间（但此时对象还没进行初始化）
3. 初始化对象

解决方法：在instance前加一个volatile关键字，保证所以关于instance的操作不会进行指令重排。

1.5ThreadLocal型单例

/*ThreadLocal型单例*/
public class Singleton8 {
    private static Singleton8 instance = null;
    private Singleton8(){}
    private static final ThreadLocal<Singleton8> threadLocalSingleton=new ThreadLocal<>(){
        @Override
        protected Singleton8 initialValue() {
            return new Singleton8();
        }
    };

    public static Singleton8 getInstance(){
        return threadLocalSingleton.get();
    }
}

ThreadLocal型只能保证在同一个线程下是单例的，不同线程不是单例的

1.6CAS型单例

CAS：Compare And Swap

/*CAS型单例 利用Java的原子性*/
public class Singleton9 {
    private static final AtomicReference<Singleton9> instance = new AtomicReference<>();
    private Singleton9(){}
    public static final Singleton9 getInstance(){
        while(true) {
            Singleton9 current = instance.get();
            if (current != null) {
                return current;
            }
            current = new Singleton9();
            if (instance.compareAndSet(null, current)) {//instance是原子性操作，相当于加锁
                return current;
                /*
                    CAS虽然返回的是同一个对象，但在多线程下会产生垃圾对象
                */
            }
        }
    }
}