设计模式——单例模式

单线程可以使用：饿汉式单例模式；

多线程可以使用：多重检查的单例模式；内部类实现的单例模式；枚举类型的单例模式；

单例模式

单例模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

单例模式通用类图（饿汉式单例），可以看出：

• Singleton类称为单例类；
• 将构造函数变为private，确保在一个应用中只产生一个实例；
• 通过new，在类内自行实例化的；
• 通过get方法返回对象。

public class Singleton {
    //通过new，在类内自行实例化的
    private static final Singleton singleton = new Singleton(); 
    //构造函数变为private，限制产生多个对象 
    private Singleton(){ 
    }
    //通过该方法获得实例对象 
    public static Singleton getSingleton(){ 
        return singleton; 
    }
    //类中其他方法，尽量是static 
    public static void doSomething(){} 
}

单例模式的优点：

• 减少内存开支，特别是一个对象需要频繁地创建、销毁时。
• 减少系统的性能开销，当一个对象的产生需要比较多的资源（读取配置、产生其他依赖对象等）时，可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决（在Java EE中采用单例模式时需要注意JVM垃圾回收机制）。
• 避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
• 可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

单例模式的缺点：

• 单例模式一般没有接口，扩展很困难。当然，在特殊情况下，单例模式可以实现接口、被继承等。
• 单例模式对测试是不利的。
• 单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，是不是要单例取决于环境。

单例模式的适用场景：

• 要求生成唯一序列号的环境；
• 在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；
• 创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；
• 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（也可以直接声明为static的方式）。

单例模式的另一种表现形式：

public class Singleton {
    private static Singleton singleton = null;
    private Singleton(){
    
    }
    public static Singleton getSingleton(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

该形式称为懒汉式单例，它是不安全的，当多个线程同时访问代码时，可能出现产生多个对象的情况。

我们可以通过在getSingleton方法前加synchronized关键字，或在getSingleton方法内增加synchronized来实现。当然，还是不建议用这种实现方式。

在Java中，对象默认是不可以被复制的，若实现了Cloneable接口，并实现了clone方法，则可以直接通过对象复制方式创建一个新对象，对象复制是不用调用类的构造函数，因此即使是私有的构造函数，对象仍然可以被复制。

---

单例模式的扩展

如果一个类可以产生多个对象，对象的数量不受限制，则是非常容易实现的，直接使用 new关键字就可以了，如果只需要一个对象，使用单例模式就可以了。那么，如果要求一个类只能产生两三个对象呢？

我们以同一时期存在两个皇帝为例（即父子等同朝为帝）：

public class Emperor {
    //定义最多能产生的实例数量
    private static int maxNumOfEmperor = 2;
    //每个皇帝都有名字，使用一个ArrayList来容纳，每个对象的私有属性
    private static ArrayList<String> nameList=new ArrayList<String>();
    //定义一个列表，容纳所有的皇帝实例
    private static ArrayList<Emperor> emperorList=new ArrayList<Emperor>();
    //当前皇帝序列号
    private static int countNumOfEmperor = 0;
    //产生所有的对象
    static{
        for(int i = 0;i < maxNumOfEmperor;i ++){
            emperorList.add(new Emperor("皇" + ( i + 1 ) + "帝"));
        }
    }
    private Emperor(){
    //世俗和道德约束你，目的就是不产生第二个皇帝
    }
    //传入皇帝名称，建立一个皇帝对象
    private Emperor(String name){
        nameList.add(name);
    }
    //随机获得一个皇帝对象
    public static Emperor getInstance(){
        Random random = new Random();
        //随机拉出一个皇帝，只要是个精神领袖就成
        countNumOfEmperor = random.nextInt(maxNumOfEmperor);
        return emperorList.get(countNumOfEmperor);
    }
    //皇帝发话了
    public static void say(){
        System.out.println(nameList.get(countNumOfEmperor));
    }
}

在Emperor中使用了两个ArrayList分别存储实例和实例变量。如果考虑到线程安全问题可以使用Vector来代替。

臣子参拜皇帝的过程：

public class Minister {
    public static void main(String[] args) {
        //定义5个大臣
        int ministerNum =5;
        for(int i=0;i<ministerNum;i++){
            Emperor emperor = Emperor.getInstance();
            System.out.print("第"+(i+1)+"个大臣参拜的是：");
            emperor.say();
        }
    }
}

结果：

这种需要产生固定数量对象的模式就叫做有上限的多例模式，它是单例模式的一种扩展，它可以在设计时决定在内存中有多少个实例，方便系统进行扩展，修正单例可能存在的性能问题，提供系统的响应速度。

在Spring中，每个Bean默认就是单例的。

---

双重检查的单例模式（推荐使用）

class Singleton {
    private static volatile Singleton instance;
    private Singleton(){}

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同事解决懒加载的问题
    //同时保证了效率，推荐使用

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

优缺点：

• Double-Check概念是多线程开发中常使用到的，代码中，我们进行了两次if(singleton == null) 检查，这样就可以保证线程安全了。
• 实例化代码只有执行一次，后面再次访问时，判断if(singleton==null)，直接return 实例化对象，也避免了反复进行方法同步。
• 线程安全；延迟加载；效率较高；

结论：在实际开发中，推荐使用这种单例设计模式。

---

静态内部类实现单例模式（推荐使用）

class Singleton {
    private static volatile Singleton instance;
    private Singleton(){}

    //写一个静态内部类，该类中有一个静态属性Singleton
    private static class SingletonInstance {
        private static final Singleton ISTANCE = new Singleton();
    }

    //提供一个静态的公有方法，直接放回SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优缺点：

• 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
• 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装在SingletonInstance类，从而完成Singleton的实例化。
• 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
• 结论：推荐使用。

---

枚举实现单例模式

enum Singleton {
    INSTANCE;
    public void method() {
        //方法
    }
}

优缺点：

• 借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
• 这种方式是Effective Java作者Josh Bloch提倡的方式。
• 结论：推荐使用。