单例设计模式的几种实现方式

设计模式

1.单例设计模式

单例设计模式简介

单例设计模式中,单例对象的类必须保证在jvm中只存在一个实例.

应用:Spring中的Bean默认都是单例的.线程池,缓存,日志对象等一般设计成单例的.

实现单例模式的思路为:先私有化构造方法;创建本类对象并提供公共的方法方式;

1.1经典的懒汉模式

所谓懒汉模式,是指需要单例对象的时候,才创建类的实例.这种方式在多线程下可能会创建多个对象,是线程不安全的.多线程下可能导致单例模式失效.

package com.begank.revival.juc.singleton;

/**
 * @ClassName :经典的懒汉式单例模式
 * @Author : begank
 */
public class LazySingleton {
    //懒汉对象引用
    private static LazySingleton INSTANCE;

    //私有化构造方法
    private LazySingleton(){}

    //提供公共的访问方式
    public static LazySingleton getInstance(){
        //多线程下,懒汉式是不安全的,因为有可能同时有多条线程进入下面的判断,导致创建多个对象
        if (INSTANCE == null){
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

1.2经典的饿汉式

所谓饿汉式,是指类一加载,类对象就创建了.饿汉式是"天然"的线程安全的,因为饿汉式利用类加载只会加载一次这个特性(这是Java虚拟机提供的).

饿汉式有可能会造成资源的浪费,即创建了对象但并没有使用.但是我觉得这个可以忽略,因为不太可能出现触发加载这个类,但不使用这个对象的情况.

package com.begank.revival.juc.singleton;

/**
 * @ClassName :饿汉式单例模式
 * @Author : begank
 */
public class HungrySingleton {

    //在类加载的时候,就创建类对象.由于类只会加载一次,所以保证其是线程安全的
    private static HungrySingleton INSTANCE = new HungrySingleton();

    private HungrySingleton(){}

    public static HungrySingleton getInstance(){
        return INSTANCE;
    }
}

1.3双重锁校验懒汉式-DCL

双重锁校验模式是一种比较优雅的单例实现,既可以保证有需要才创建对象,又可以保证只创建一个对象.其中:

1. 实例对象加volatile关键字,是因为volatile关键字可以禁止指令重排,指令重排优化可能导致instance对象还没有创建,就已经赋值给了Instance引用,从而其他线程获得一个null对象.
2. 所谓指令重排,是指CPU不按照程序指定的顺序执行指令,但会保证执行结果的准确性.比如代码写的是A xx ; B xx; C= Axx;CPU在实际执行时,有可能先执行C语句再执行A语句,因为他们没有先后依赖关系.也不会改变程序结果.
3. 锁不加在方法上,避免每次获取实例都需要加锁,加锁是一个很耗性能的过程.
4. 在创建对象前再一次判断对象是否为空,避免两个线程同时排队获取锁对象时,第二个线程再次创建对象.

package com.begank.revival.juc.singleton;

/**
 * @ClassName :双重锁校验懒汉式单例
 * @Author : begank
 */
public class DoubleCheckSingleton {

    /**
     * 加volatile关键字,可以禁止指令重排.
     * 指令重排优化可能导致instance对象还没有创建,就已经赋值给了Instance引用,从而其他线程获得一个null对象.
     */
    private static volatile DoubleCheckSingleton INSTANCE;

    private DoubleCheckSingleton(){}

    /**
     * 双重锁校验机制;
     * 锁不加在方法上,避免每次获取实例都需要加锁,加锁是一个很耗性能的过程
     */
    public static DoubleCheckSingleton getInstance(){
        //第一次判断,如果对象还未创建,则获取锁对象.
        if (INSTANCE == null){
            synchronized (DoubleCheckSingleton.class){
                //第二次判断,有可能两个线程同时进入第一层判断,即此时对象未创建.
                //此时,两个线程依次排队希望获取锁对象.所以在实际创建对象前,还需要再判空.
                if (INSTANCE == null){
                    INSTANCE = new DoubleCheckSingleton();
                }
            }
        }

        return INSTANCE;
    }
}

1.4静态内部类模式单例

内部类模式单例,通过在单例对象中创建内部类的形式,在静态内部类中创建单例对象,由单例类提供公共访问方式供外部获取.

package com.begank.revival.juc.singleton;

/**
 * @ClassName :内部类单例模式
 * @Author : begank
 */
public class InnerSingleton {
    
    private InnerSingleton(){}

    public static InnerSingleton getInstance(){
        return Holder.INSTANCE;
    }

    private static class Holder{
        static InnerSingleton INSTANCE = new InnerSingleton();
    }
}

1.5枚举实现单例

以上的所有方法,在反射和反序列化时,都有可能失效.Java反射是可以创建构造方法为private的类的.

使用枚举可以优雅的实现单例模式.

package com.begank.revival.juc.singleton;

/**
 * @ClassName :枚举模式单例
 * @Author : begank
 */
public enum EnumSingleton {
    /**
     * 单例对象
     */
    INSTANCE;
    
    public EnumSingleton getInstance(){
        return INSTANCE;
    }
}