第3章 创建型模式-单例模式

创建型模式（Creational Pattern）是对类的实例化过程的抽象化，能够提供对象的创建和管理职责;

创建型模式共有5种：
■ 单例模式；
■ 工厂方法模式；
■ 抽象工厂模式；
■ 建造者模式；
■ 原型模式;

确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例;
两种表现形式:
■ 饿汉式单例类：类加载时，就进行对象实例化；
■ 懒汉式单例类：第一次引用类时，才进行对象实例化;

■ 饿汉式单例类

public class Singleton {
    private static Singleton singleton = new Singleton();

    /**
     * 构造方法私有，保证外界无法直接实例化
     */
    private Singleton(){
        
    }

    /**
     * 通过该方法获得实例对象
     * @return
     */
    public static Singleton getInstance(){
        return singleton;
    }
}

■ 懒汉式单例类

public class Singleton {
    private static Singleton singleton = null;

    /**
     * 构造方法私有，保证外界无法直接实例化
     */
    private Singleton(){

    }

    /**
     * 方法同步
     * @return
     */
    synchronized public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

懒汉式单例类中对静态方法 getInstance()进行同步，以确保多线程环境下只创建一个实例;

饿汉式单例类与懒汉式单例类之间的区别:
■ 饿汉式单例类在被加载时实例化，而懒汉式单例类在第一次引用时实例化；
■ 从资源利用效率上说，饿汉式单例类要差一些，但从速度和反应时间角度来讲，饿汉式单例类则比懒汉式单例类稍好些；
■ 饿汉式单例类更符合Java语言本身的特点;

单例模式的优点:
■ 由于单例模式在内存中只有一个实例，减少了内存的开支;
  特别是一个对象需要频繁地创建、销毁，而且创建或销毁的性能又无法优化时，单例模式的优势就非常明显;
■ 当一个对象的产生需要比较多资源时，则可以通过在启用时直接产生一个单例对象，然后用永久驻留内存的方式来解决;
  例如，如读取配置、产生其他依赖对象时；
■ 单例模式可以避免对资源的多重占用;
  例如，一个写文件动作，由于只有一个实例存在于内存中，避免了对同一个资源文件的同时操作;
■ 单例模式可以在系统设置全局的访问点，优化和共享资源访问;
  例如，可以设计一个单例类，负责所有数据表的映射处理;

单例模式的缺点:
■ 单例模式无法创建子类，扩展困难;
  若要扩展，除了修改代码基本上没有第二种途径可以实现;
■ 单例模式对测试不利;
  在并行开发环境中，如果采用单例模式的类没有完成，是不能进行测试的；单例模式的类通常不会实现接口，这也妨碍了使用mock的方式虚拟一个对象;
■ 单例模式与单一职责原则有冲突;
  一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要用单例模式取决于环境，单例模式把“要单例”和业务逻辑融合在一起;

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

根据功能，单例类可以分为有状态单例类和无状态单例类:
■ 有状态单例类：一个有状态单例类的对象一般是可变的，通常当做状态库使用;
  例如，给系统提供一个唯一的序列号;
■ 无状态单例类：无状态单例类是不变的，通常用来提供工具性的功能方法;
  例如，IO或数据库访问等。

■ 单例类仅局限于一个JVM;
  因此当多个JVM的分布式系统时，这个单例类就会在多个JVM中被实例化，造成多个单例对象的出现;
  如果是无状态的单例类，则没有问题，因为这些单例对象是没有区别的;
  如果是有状态的单例类，则会出现问题;
■ 同一个JVM中会有多个类加载器;
  当两个类加载器同时加载同一个类时，会出现两个实例，此时也应尽量避免使用有状态的单例类;
■ 使用单例模式时，需要注意序列化和克隆对实例唯一性的影响;
  如果一个单例的类实现了Serializable或Cloneable接口，则有可能被反序列化或克隆出一个新的实例来，从而破坏了“唯一实例”的要求，因此，通常单例类不需要实现Serializable和Cloneable接口;

■ 单例模式的实例

public class GloNum {

    /**
     * 书中没有这个私有构造方法，是不对的
     */
    private GloNum(){

    }

    private static GloNum gloNum = new GloNum();

    private int num = 0;

    public static GloNum getInstance(){
        return gloNum;
    }

    /**
     * 使用synchronized对该方法进行线程同步
     * @return
     */
    public synchronized int getNum(){
        return ++num;
    }
}

public class SingleDemo {

    public static void main(String[] args){
        NumThread threadA = new NumThread("线程A");
        NumThread threadB = new NumThread("线程B");
        threadA.start();
        threadB.start();
    }
}

class NumThread extends Thread{

    private String threadName;

    public NumThread(String name){
        this.threadName = name;
    }

    @Override
    public void run() {
        GloNum gloNum = GloNum.getInstance();
        for(int i = 0; i < 5; i++){
            System.out.println(threadName + "第 " + gloNum.getNum() + " 次访问;");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

#运行结果每次都有可能出现不同：
线程B第2 次访问;
线程A第1 次访问;
线程A第3 次访问;
线程B第4 次访问;
线程B第6 次访问;
线程A第5 次访问;
线程B第8 次访问;
线程A第7 次访问;
线程A第9 次访问;
线程B第10 次访问;

参考：
摘录 《设计模式（Java版）》韩敬海主编；（微信读书APP中有资源，可以直接阅读）