设计模式之单例模式

意图

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

使用场景

1. 要求产生唯一的序列号
2. 创建一个对象需要消耗大量资源，比如IO与数据库的连接

实现

首先令构造函数私有化，再提供一个静态方法获取实例。

几种单例模式的实现方法

懒汉式

public class Singleton1 {
    private static Singleton1 singleton1;

    private Singleton1(){}

    public static Singleton1 getInstance(){
        if (singleton1 == null) {
            singleton1 = new Singleton1();
        }
        return singleton1;
    }
}

缺点：由于没有加锁，线程不安全，严格意义上不算单例模式。

public class Singleton2 {
    private static Singleton2 singleton2;

    private Singleton2(){}

    public static synchronized Singleton2 getInstance() {
        if (singleton2 == null) {
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

优点：调用时才初始化，避免内存浪费。
缺点：虽然加了锁保证线程安全，但是效率低

饿汉式

public class Singleton3 {
    private static Singleton3 singleton3 = new Singleton3();

    private Singleton3(){}

    public static Singleton3 getInstance(){
        return singleton3;
    }
}

优点：没有加锁，效率提高了。
缺点：类加载时就初始化浪费内存

双重校验锁

public class Singleton4 {
    private volatile static Singleton4 singleton4;

    private Singleton4(){}

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

优点：线程安全且效率较高 缺点：实现比较复杂

登记式/内部静态类

public class Singleton5 {
    private static class SingletonHolder {
        private final static Singleton5 INSTANCE = new Singleton5();
    }

    private Singleton5(){}

    public static final Singleton5 getInstance() {
        return  SingletonHolder.INSTANCE;
    }
}

枚举类

public class Singleton6 {
    private Singleton6(){}

    private enum Singleton {
        INSTANCE;
        private Singleton6 singleton6;

        private Singleton(){
            singleton6 = new Singleton6();
        }

        public  Singleton6 getInstance(){
            return singleton6;
        }
    }
}

描述：目前最好的方法。