设计模式 — 单例模式

思想： 确保一个类只有一个实例，并提供该实例的全局访问点。

实现：

使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。

私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

单例模式有八种方式：

1) 饿汉式(静态常量)
Java 代码实现

package singleton;

public class Singleton1 {
    private  Singleton1(){}

    //饿汉式，不能实现懒加载，可能浪费内存
    private final static Singleton1 INSTANCE = new Singleton1();

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

2) 饿汉式（静态代码块）
Java 代码实现

package singleton;

//饿汉式，不能实现懒加载，可能浪费内存
public class Singleton2 {
    private Singleton2(){}

    private final static Singleton2 instance;

    static {
        instance = new Singleton2();
    }

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

3. 懒汉式(线程不安全)
   Java 代码实现

package singleton;

//懒汉式，可以实现懒加载，存在线程安全问题，只能在单线程下使用
public class Singleton3 {
    private Singleton3(){}

    private static Singleton3 instance;

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

4. 懒汉式(线程安全，同步方法)
   Java 代码实现

package singleton;

//懒汉式，实现了懒加载和线程安全，但效率低下，存在性能问题
public class Singleton4 {
    private Singleton4(){}

    private static Singleton4 instance;

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

5. 懒汉式(线程安全，同步代码块)
   Java 代码实现

package singleton;

//懒汉式，无法实现线程安全，只能在单线程下使用，不推荐使用
public class Singleton5 {
    private Singleton5() {
    }

    private static Singleton5 instance;

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

6) 双重检查
Java 代码实现

package singleton;

//双重检验锁，推荐使用
public class Singleton6 {
    private Singleton6() {
    }

    private static Singleton6 instance;

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

7) 静态内部类
Java 代码实现

由 JVM 来保证只会在第一次使用静态内部类的时候加载

package singleton;

//使用静态内部类方式,利用类加载机制实现懒加载和线程安全，推荐使用
public class Singleton7 {
    private Singleton7(){}

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

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

8) 枚举
Java 代码实现

Java 的枚举类在 JDK 1.5 之后引入，其默认的构造方法是私有的，在我们访问枚举实例时会执行构造方法，同时每个枚举实例都是 static final 类型的，也就表明只能被实例化一次。在调用构造方法时，我们的单例被实例化。
也就是说，因为 enum 中的实例被保证只会被实例化一次，所以我们的 INSTANCE 也被保证实例化一次。

package singleton;

//利用枚举类的性质实现线程安全和懒加载，而且还能防止反序列化重新创建新的对象，推荐使用
public enum  Singleton8 {
    INSTATCE;

    public static Singleton8 getInstance(){
        return INSTATCE;
    }
}

单例模式注意事项和细节说明

1. 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能

2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new

3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)