设计模式GOF23——单例模式

单例模式（Singleton）是创建者模式的一种，是负责创建对象的模式。

模式解决的问题

该模式的核心是保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

模式的优点

由于单例模式只生成一个单例，减少了系统性能的开销，当一个对象的产生需要较多的资源时，例如读取配置、产生其他依赖对象时，则可以通过在应用启动时产生一个单例对象，然后永久驻留在内存的方式解决。
单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设置一个单例类，负责所有数据表的映射处理。

模式的缺点

一、开销
虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
二、可能的开发混淆
使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
三、对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中，只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。

模式的实现方式

1. 饿汉式（线程安全，调用率高，但是，不可以延时加载）
   饿汉式是在对象创建的时候就直接赋值。

public class Singleton {
    //单例的对象在创建的时候初始化，private保证外部不能随便访问，static让外部类可以通过getInstance（）方法访问
    private static Singleton singleton = new Singleton();
    //把构造方法私有化，防止外部创建类对象
    private Singleton(){}
    //对外设定的可以访问类的方法
    public static Singleton getInstance(){
        return singleton;
    }
}

调用的时候也很简单
Singleton s = Singleton.getInstance();
就可以了。
2. 懒汉式（线程安全，调用率高，但是，可以延时加载）
懒汉式是在调用的时候再创建对象

public class Singleton {
    //private保证外部不能随便访问，static让外部类可以通过getInstance（）方法访问
    private static Singleton singleton = null;
    //把构造方法私有化，防止外部创建类对象
    private Singleton(){}
    //对外设定的可以访问类的方法,没有对象的话创建对象，synchronized保证线程安全
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

调用的时候也很简单
Singleton s = Singleton.getInstance();
3. 双重检索式（由于JVM底层内部模型原因，偶尔会出问题）
双重检索式是用双重锁的方式保证创建对象的线程安群问题

public class Singleton {
    //private保证外部不能随便访问，static让外部类可以通过getInstance（）方法访问
    private static Singleton singleton = null;
    //把构造方法私有化，防止外部创建类对象
    private Singleton(){}
    //对外设定的可以访问类的方法,没有对象的话创建对象，synchronized保证线程安全
    //synchronized放在方法里面会减少线程冲突的可能性，不用每次都同步，提高效率
    public static  Singleton getInstance(){
        if (singleton == null) {  
            synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
            }  
        }  
        return singleton; 
    }
}

调用的时候也很简单
Singleton s = Singleton.getInstance();
4. 静态内部类（线程安全，调用率高，但是，可以延时加载）
静态内部类是用静态内部类的方式创建对象

public class Singleton {
    //静态内部类创建对象，因为是静态内部类，又是私有类，所以只有本类可以访问
     private static class SingletonHolder {  
            private static final Singleton INSTANCE = new Singleton();  
    }  
    //把构造方法私有化，防止外部创建类对象
    private Singleton(){}
    //对外设定的可以访问类的方法,访问静态内部类的对象
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}

调用的时候也很简单
Singleton s = Singleton.getInstance();
5. 枚举单例（线程安全，调用率高，不能延时加载）
用枚举类来保存对象，枚举类本身就是天然单例模式。

public enum Singleton {  
    INSTANCE;  
}

调用的时候也很简单
Singleton s = Singleton.INSTANCE;
6. 静态块（线程安全，调用率高，不能延时加载）
用静态块的方式创建对象。

public class Singleton {
    //private保证外部不能随便访问，static让外部类可以通过getInstance（）方法访问
    private static Singleton singleton = null;
    //单例的对象在静态块初始化
    static{
        singleton = new Singleton();
    }
    //把构造方法私有化，防止外部创建类对象
    private Singleton(){}
    //对外设定的可以访问类的方法
    public static Singleton getInstance(){
        return singleton;
    }
}

调用的时候也很简单
Singleton s = Singleton.getInstance();

单例的破解

1. 单例模式可以用反射模式来调用它私有化的构造方法来破解。
   反射机制得到类的对象之后可以通过setAccessible(true)，这样就可以调用私有化构造方法。这种破解方式不能破解枚举方式的单例。如果想要保护方法不被破解，就要在私有化的构造方法中过滤条件，如果没有单例对象却调用构造方法，就报错，就可以不被这种方法破解。
2. 单例模式也可以通过序列化和反序列化的方式破解。
   通过反序列化时的readObject()方法来获取单例对象，但是这个破解方法需要单例类实现Serializable接口。保护类不被这个方法破解也很简单，可以在类中重写一个私有化的readObject()方法，使其返回单例对象。