设计模式之一 单例设计模式

一、简介

单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。

许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

二、适用场合

• 需要频繁的进行创建和销毁的对象；
• 创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
• 工具类对象；

• 频繁访问数据库或文件的对象

  资源管理器,回收站,打印机资源,线程池,缓存,配置信息类,管理类,控制类,门面类,代理类通常被设计为单例类

要求：

（1）单例类只能有一个实例

（2）单例类必须自己创建自己的唯一实例

（3）单例类必须给其他对象提供这一实例

三、单例实现方式

基本思路：

1、有一个私有的实例对象，对象是唯一的，用final修饰

private final static Singleton singleton= new  Singleton();

2、构造函数私有化，防止通过构造函数生成该类的对象

private Singleton(){}

3、提供函数来获取该唯一的对象，并且不能通过构造函数生成该类对象，只能通过类访问函数，所以是static的，相应的实例对象也是static的

public static  Singleton getInstance(){
    return singleton;
}

这样就得到了单例模式饿汉式的写法：

//饿汉式-1
public class Singleton {

    private final static Singleton singleton= new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return singleton;
    }
}

饿汉式的优点是写法简单，在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

另一种饿汉式的变体是采用静态代码块的方法

//饿汉式-2
public class Singleton {

    private static Singleton singleton;

    static {
        singleton= new Singleton();
    }

    private Singleton() {}

    public Singleton getInstance() {
        return singleton;
    }
}

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

如果我们希望单例类可以延迟加载，达到lazy loading，而不是类装载的时候就完成实例化，我们就可以采用懒汉式。

//懒汉式-1  多线程下不可用
public class Singleton {

    private static Singleton singleton;

    private Singleton(){}

    public static Singleton getInstance(){

        if(singleton == null){ 
            singleton= new Singleton();         
        }
        return singleton;
    }

}
问题：只能在单线程的情况下使用，多线程的时候会生成多个实例。

如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

为了解决多线程下会产生多个实例的问题，我们可以对获取实例进行加锁控制，得到如下变体形式

//懒汉式-2 
public class Singleton {

    private static Singleton singleton;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

解决上面懒汉式-1的线程不安全问题，做个线程同步就可以了，于是就对getInstance()方法进行了线程同步。

但是这种方法的缺点是效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。既然用同步方法效率太低那么就改用同步代码块的方式，例如如下的方式：

//懒汉式-3
public class Singleton {

    private static Singleton singleton;

    private Singleton(){}

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

但是这种方式仍然会出现懒汉式-1相同的问题，在多线程的情况下仍然会产生多个实例。因此我们可以对上面的代码继续改造，进行双重判断。

//懒汉式-4
public class Singleton {

    private static Singleton singleton;

    private Singleton(){}

    public static  Singleton getInstance(){

        if(singleton == null){ 
            synchronized(Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }               
        }
        return singleton;
    }
}

Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

它的优点是：线程安全；延迟加载；效率较高。

还有一种静态内部类的单例实现方法如下：

//静态内部类实现单例
public class Singleton {

    private Singleton(){}

    private static class SingletonInstance {
        private static final Singleton singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonInstance.singleton;
    }

}

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

四、单例攻击

4.1 利用java反射机制进行攻击

尽管如此，以上的单例模式实现方式仍然可能受到攻击，可以通过Java反射机制和序列化进行攻击。

public class SingletonAttack {

    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
        Class<?> classType = Singleton.class;
        Constructor<?> c = classType.getDeclaredConstructor(null);
        c.setAccessible(true);
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = (Singleton) c.newInstance();
        System.out.println(s1==s2);

    }
//得到的结果为false

通过反射获取构造函数，然后调用setAccessible(true)就可以调用私有的构造函数，所有s1和s2是两个不同的对象。如果要抵御这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常。

public class Singleton {
    //注意不要忘记加static，否则不起作用
    private  static boolean flag = false;
    private  Singleton(){
        synchronized(Singleton.class){
            if(flag == false){
                flag =!flag;
            }
            else{
                throw new RuntimeException("单例模式被攻击");
            }
        }               
    }

    private static class SingletonInstance {
        private static final Singleton singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonInstance.singleton;
    }

}

4.2 利用序列化进行单例模式攻击

//单例类实现Serializable接口
public class Singleton implements Serializable {

    private static final long serialVersionUID = 1L;

    private  static boolean flag = false;
    private  Singleton(){
        synchronized(Singleton.class){
            if(flag == false){
                flag =!flag;
            }
            else{
                throw new RuntimeException("单例模式被攻击");
            }
        }       
    }

    private static class SingletonInstance {
        private static final Singleton singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonInstance.singleton;
    }

}

此时我们利用序列化进行攻击代码如下：

public class SingletonAttack {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Singleton s1 = Singleton.getInstance();

        FileOutputStream fos = new FileOutputStream("d://a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s1);
        oos.flush();
        oos.close();
        fos.close();

        FileInputStream fis = new FileInputStream("d://a.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Singleton s2 = (Singleton) ois.readObject();
        ois.close();
        fis.close();
        System.out.println(s1 == s2);   
    }
}
//返回结果为false

如果过该类implements Serializable，那么就会在反序列化的过程中重新创建一个对象。这个问题的解决办法就是在反序列化时，指定反序化的对象实例，可以在单例类中添加readResolve方法。

package com.cmbchina.cc.crs.wjjDemo;

import java.io.Serializable;

public class Singleton implements Serializable {

    private static final long serialVersionUID = 1L;

    private  static boolean flag = false;
    private  Singleton(){
        synchronized(Singleton.class){
            if(flag == false){
                flag =!flag;
            }
            else{
                throw new RuntimeException("单例模式被攻击");
            }
        }       
    }

    private static class SingletonInstance {
        private static final Singleton singleton = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonInstance.singleton;
    }

    private Object readResolve(){
        return SingletonInstance.singleton;
        }

}

添加后再执行序列化攻击的代码执行结果为true。

五、枚举实现单例

除此此外，在JDK1.5中添加了枚举可以用来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化和java反射重新创建新的对象。

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {

    }
}

采用java反射方式创建实例时，会报java.lang.NoSuchMethodException异常。

同样将Singleton类实现Serializable接口，在无需添加readResolve方法的情况下，执行序列化攻击代码返回结果仍然为true。所以总的来说，用枚举实现单例是比较安全且简单的方法。