四种单例模式（java）

单例模式

目标：保证一个类只有一个实例；
实现：不可被外部创建；
限制外部访问方式；
内部只创建一个唯一的实例；

单例模式实现

1.饿汉式

/**
 * 饿汉式单例，创建类时创建单例，线程也不安全
 */
public class SingletonHungary {

    private static final SingletonHungary instance = new SingletonHungary();

    private SingletonHungary(){}

    public static SingletonHungary getInstance() {
        return instance;
    }

}

特点：由内部直接创建资源，创建类时创建单例会浪费不必要的资源。

2.懒汉式

/**
 * 懒汉式单例，需要时创建单例（线程不安全版本）
 */
public class SingletonLazy{

    private static SingletonLazy instance ;

    private SingletonLazy(){}

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

}

特点：为了避免懒汉式那样浪费资源，所以在需要的时候调用静态方法从而实例化对象。但是在特定时候两次及以上同时调用会产生死锁的情况，所以是线程不安全的。

3.DCL

package me.maiz.se.mini.deignpattern;

/**
 * 懒汉式单例，需要时创建单例（线程安全版本,使用了双重检查锁DCL机制）
 */
public class SingletonDoubleChecking {

    private static SingletonDoubleChecking instance ;

    private SingletonDoubleChecking(){}

    public static SingletonDoubleChecking getInstance() {
        //检查是否为空，不为空时不检查，节省性能消耗;为空时可能有并发问题
        if(instance==null){
            //同步代码块，保证不会被并发获取
            synchronized(SingletonDoubleChecking.class) {
                //进入时再次判断，若不为空则不建实例，保证单例
                if (instance==null) {
                    instance = new SingletonDoubleChecking();
                }
            }
        }
        return instance;
    }

}

特点：为了线程安全首先想到的是在java中加 synchronized修饰，但是每一次使用的时候都去排队降低了效率。所以我们在还没有实例化对象的之前防止死锁，如果已经有一个实例就不用考虑同时创建而形成死锁了。

4.枚举

/**
 * 枚举式单例，枚举的创建由JVM保证，因此不会出现并发问题，构造器自动私有，外部不能创建，只能引用
 * 用法为：SingletonEnum.INSTANCE.doSomething();
 */
public enum SingletonEnum {
    //唯一实例，默认为public static final的
    INSTANCE;

    public String name;

    public void doSomething(){
        System.out.println("doSomething");
    }

    public static void main(String[] args) {
        SingletonEnum.INSTANCE.doSomething();
    }

}

特点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。