几种单例模式的总结

原由

	今天在进行jackson 和fastjson 序列化的性能测试时,发现jackson中需要创建ObjectMapper mapper=new ObjectMapper( ),如果此处创建实例对象的方法放在时间戳之内,在多线程下,jackson序列化耗时就特别长
	反之,通过单例模式创建此对象,保证实例仅有一个,jackson的性能将比fastjson提升一倍.
	
	不由的想起来了单例模式的重要性,便做了一些总结:

00单例定义及测试代码

/*
    单例的定义: 类的对象只能允许一个实例存在.

    基本实现思路:
        1.构造器私有,避免外界创建(new)
        2.静态方法(getInstance)获取实例,为空,创建实例,不为空,就直接返回实例.

    场景:需要频繁的创建或消费的对象
        经常用的对象,但创建耗时耗资源
        工具类对象
 */
public class Test {
    public static void main(String[] args) {
        for (int i = 0; i <10 ; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Singleton08.getInstance());
                }
            }).start();
        }
    }
}

01饿汉式单例设计模式----静态变量

/*
    饿汉式单例设计模式----静态变量
    优点:在类加载时就完成实例的创建;实例被存放于内存中;线程安全
    缺点:如果一直未使用这个实例,那么创建它属于内存浪费.
 */
public class Singleton01 {
    private static Singleton01 instance = new Singleton01();//静态变量

    private Singleton01() {//单例模式不允许外界直接创建,因此默认构造器私有
    }

    public static Singleton01 getInstance() {//公有和静态,以便获取实例
        return instance;
    }
}

02饿汉式单例设计模式----静态代码块

/*
    饿汉式单例设计模式----静态代码块
    优点:在类加载时就完成实例的创建;实例被存放于内存中;线程安全
    缺点:如果一直未使用这个实例,那么创建它属于内存浪费.
 */
public class Singleton02 {
    private static Singleton02 instance ;

    static {
        instance = new Singleton02();//静态代码块
    }

    private Singleton02() {//单例模式不允许外界直接创建,因此默认构造器私有
    }

    public static Singleton02 getInstance() {//公有和静态,以便获取实例
        return instance;
    }
}

03懒汉式单例设计模式----线程不安全

/*
    懒汉式单例设计模式----线程不安全
    优点:lazy loading
    缺点:线程不安全(仅支持单线程下使用),多线程下会导致多个实例并存.
    特点:多线程下,一个线程进入if判断,还未往下执行,另一个线程也进入了if判断语句,导致多例产生.
 */
public class Singleton03 {
    private static Singleton03 instance;

    private Singleton03() {//单例模式不允许外界直接创建,因此默认构造器私有
    }

    public static Singleton03 getInstance() {
        if (null==instance) {
            instance = new Singleton03();
        }
        return instance;
    }
}

测试:

Singleton03@39531411
Singleton03@39531411
Singleton03@74529643
Singleton03@39531411
Singleton03@74529643
Singleton03@39531411
Singleton03@39531411
Singleton03@39531411
Singleton03@39531411
Singleton03@39531411

结论:此种单例模式,多线程下,存在多个实例.

04懒汉式单例设计模式----加锁

/*
    懒汉式单例设计模式----加锁
    优点:lazy loading;线程安全
    缺点:加锁之后,导致性能下降,资源浪费.
 */
public class Singleton04 {
    private static Singleton04 instance;

    private Singleton04() {//单例模式不允许外界直接创建,因此默认构造器私有
    }

    public static synchronized Singleton04 getInstance() {
        if (null==instance) {
            instance = new Singleton04();
        }
        return instance;
    }
}

05双重锁校验单例设计模式

/*
    双重锁校验单例设计模式
    优点:lazy loading;线程安全;效率较高;
    特点:进行了2次判断;volatile的可见性
 */
public class Singleton05 {
    private static volatile Singleton05 instance;

    private Singleton05() {//单例模式不允许外界直接创建,因此默认构造器私有
    }

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

06静态内部类单例设计模式

/*
    静态内部类单例设计模式
    优点:lazy loading;线程安全;效率较高
    特点:只有在使用静态内部类的时候静态内部类才会实例化,只有使用到了静态内部类才会实例化该对象.不会造成对资源的浪费.


 */
public class Singleton06 {
    private static class SingletonHolder {
        private static Singleton06 instance=new Singleton06();
    }

    private Singleton06() {//单例模式不允许外界直接创建,因此默认构造器私有
    }

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

07枚举单例设计模式

/*
    枚举单例设计模式
    优点:线程安全;防止反序列化重新创建新的对象
 */
public enum Singleton07 {
    INSTANCE;

    public void whateverMethod() {
    }
}

08CAS「AtomicReference」单例设计模式

import java.util.concurrent.atomic.AtomicReference;

/*
     CAS「AtomicReference」单例设计模式
    优点:线程安全;不需要使用锁
    缺点:由于依赖于cas的忙等算法,如果一直没有获取就会处于死循环.
 */
public class Singleton08 {
    private static final AtomicReference<Singleton08> INSTANCE = new AtomicReference<Singleton08>();
    private static Singleton08 instance;

    private Singleton08() {
    }

    public static Singleton08 getInstance() {
        while(true) {
            Singleton08 instance = INSTANCE.get();
            if (null == instance) {
                INSTANCE.compareAndSet(null, new Singleton08());
                return instance;
            }
            return INSTANCE.get();
        }
    }
}

09注册登记式单例设计模式

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

/*
    注册登记式单例设计模式
    特点:用一个容器去装载所有的对象,并在容器中用其类的限定名登记所有的对象,如果实例对象在不存在,
        我们注册到单例注册表中,第二次取的时候根据类的限定名去取出对应的对象.不需要重新去初始化.

    参考spring创建bean方式
 */
public class Register {
    private static Map<String, Object> registerMap = new ConcurrentHashMap<>();

    private Register() {
    }

    static {
        Register register = new Register();
        registerMap.put(Register.class.getName(), register);
    }

    public static Object getInstance(String className) {
        if (null == className){
            className = "com.yczuoxin.pattern.singleton.register.Register";
        }
        if (!registerMap.containsKey(className)){
            try {
                registerMap.put(className,Class.forName(className).newInstance());
            } catch (Exception e) {
                System.out.println("请填写正确的类的全路径");
                e.printStackTrace();
            }
        }
        return registerMap.get(className);
    }
}

总结

	单例模式01,02,05,06推荐大家使用