[19/04/22-星期一] GOF23_创建型模式(单例模式)

一、概念

《Design Patterns: Elements of Reusable Object-Oriented Software》（即后述《设计模式》一书），由 Erich Gamma、Richard Helm、Ralph Johnson

和 John Vlissides 合著（Addison-Wesley，1995）。这几位作者常被称为"四人组（Group of Four）"。

创建型模式(5个)：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式；

结构型模式(7个)：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式；

行为模式(11个)：模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

1、单例模式

核心：保证一个类有且只有一个对象(实例)，并且提供一个访问该实例的全局访问点。

应用场景：Windows 的任务管理器(Task Manager)；

Windows的回收站(Recycle Bin)，在整个系统运行中，回收站一直维护着仅有的一个实例；

项目中，读取配置文件类，一般也只有一个类，没必要每次使用配置文件的数据，每次new一个对象去读取；

网站的计数器，一般也是采用单例模式，否则难以同步；

应用程序的日志，也是采用单例模式，这是由于共享文件的日志文件一直处于打开状态，因为只有一个实例去操作，否则内容不好追加；

数据库的连接池也是采用单例模式，因为数据库的连接的是一种数据库资源；

操作系统的文件系统，也是采用单例模式，因为一个操作系统只有一个文件系统；

Application 也是典型的单例模式；

在Spring中，每个Bean默认就是单例，优点是Spring容器都可以管理；

在servlet(Server Applet：小服务程序或服务连接器，Java编写的服务器端程序),每个servlet也是单例

在Spring MVC框架/struts1框架中，控制对象也是单例。

优点： 由于单例只生成一个示例，减少了系统的性能开销，当一个对象产生需要比较多的资源时，如读取配置，产生其他依赖对象时，则可以通过在应用启动时直接

产生一个单例对象，然后永久驻留内存的方式来解决。单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

5种实现方式：

主要有2种：

(1) 饿汉式(线程安全、调用效率，但是不能延时加载)

(2) 懒汉式(线程安全、调用效率不高，但是可以延时加载)

次要有3种：

(3)双重检测模式(由于JVM底层内部模型的原因，偶尔会出现问题，不建议使用)

(4)静态内部类式(线程安全、调用效率高，可以延时加载)

(5)枚举单例(线程安全、调用效率高，不能延时加载，但是可以防止反射和反序列化漏洞)

如何选用？

单例对象占用资源少，不需要延时加载： 枚举式 优于 饿汉式

单例对象占用资源大，需要延时加载：静态内部类式 优于 懒汉式

【初步认识】

/***
 * 23-1：单例模式
 * 主要有2种：
(1) 饿汉式(线程安全、调用效率，但是不能延时加载)

(2) 懒汉式(线程安全、调用效率不高，但是可以延时加载)

次要有3种：

(3)双重检测模式(由于JVM底层内部模型的原因，偶尔会出现问题，不建议使用)

(4)静态内部类式(线程安全、调用效率高，可以延时加载)

(5)枚举单例(线程安全、调用效率高，不能延时加载)
 */
package cn.sxt.pattern;

/*  1)饿汉式(单例对象立即加载)
 *    static变量会在类加载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生
 * 并发访问的问题。因此synchronized关键字可以省略。
 * 问题：如果只是加载本类，而不是调用getInstance(),甚至永远没有调用，则会造成资源浪费。
 * */
class Singleton{
    //第2步：私有化一个静态对象。类初始化时立即加载这个对象instance
    private static Singleton instance=new Singleton();//instance没什么特殊含义，用s也行,实例化对象的名字

    private Singleton() { //第1步：私有构造器，只有自己可以用

    }
    //由于加载类时，天然的线程安全，方法不用同步，调用效率高
    public static Singleton getInstance() {
        return instance;
    }
}

/* 2)懒汉式(单例对象延时加载，不立即加载,中间用的时候才去new一个新的对象)
 * 延时加载,真正用的时候才去加载！
 * 问题：资源利用率高,但是，每次调用getInstance()方法时,要使用并发，效率低
 * */
class Singleton02{
    private static Singleton02 s;
    private  Singleton02() {//私有化构造器

    }
    //为啥加同步？因为当线程A执行到s==null后,睡觉去啦,当线程B进来后发现s也是null,会去创建一个对象,当线程A醒来之后也去创建
    //一个新的对象，这样就2个对象，违反单例的定义(即一个单例类有且只有一个示例(对象))
    public static synchronized Singleton02 getInstance() {
        if (s==null) {
            s=new Singleton02();
        }
        return s;
    }
}

/*3)双重检测锁的实现(实际工作很少用)，综合了懒汉和饿汉的模式
 * 这个模式将同步的内容下放到if内部，提高了执行效率，不必每次获取对象时都进行同步，只有第一次才同步，创建对象后就没必要同步了
 * 问题：由于编译器优化的原因和JVM底层内部模型原因，偶尔会出问题
 * */

class Singleton03{
    private static Singleton03 s=null;
    private  Singleton03() {
    }

    public static Singleton03 getInstance() {

        if (s==null) {
            Singleton03 sc;
            synchronized (Singleton03.class) {
                sc=s;
                if (sc==null) {
                    synchronized (Singleton03.class) {
                        if (sc==null) {
                            sc=new Singleton03();
                        }
                    }
                    s=sc;
                }
            }
        }
        return s;
    }
}

/*4) 静态内部类的实现(也是一种懒加载)
 * 外部类没有static属性，则不会像饿汉式那样立即加载对象
 * 只有真正调用getInstance方法时才会加载静态内部类，加载类时线程是安全的,对象s是static final类型的,保证了内存中
 * 只有一个实例存在,而且只能赋值一次，从而保证了线程的安全性
 * 好处：兼备了并发高效调用和延迟加载的优势
 *
 * */

class Singleton04{
    private static class SingletonClassInstance {
        private static final Singleton04 s=new Singleton04();
    }
    //初始化Singleton04类时不会立即初始化静态内部类SingletonClassInstance,只能用到时才会通过SingletonClassInstance.s
    //去调用对象s(这里也可以看作是它的属性),延时加载
    public static Singleton04 getInstance() {
        return SingletonClassInstance.s;//
    }
    private  Singleton04() {

    }
}

/*5)枚举方式(没有懒加载)
 * 优点：实现简单，枚举本身就是单例模式。由JVM从根本上提供保障，避免通过反射和反序列的漏洞
 * 缺点：无法延时加载
 * */
enum Singleton05{//注意定义与class的区别

    //定义一个枚举元素INSTANCE，它就代表Singleton05的一个单例对象
    INSTANCE;

    //添加自己需要的操作
    public void singletonOperation() {

    }

}

public class Test_0422_Singleton {
    public static void main(String[] args) {
        /*getInstance是一个函数，在java中，可以用这种方式使用单例模式创建类的实例，所谓单例模式就是一个类有且只有一个实例，
        不像object ob=new object();的这种方式去实例化后去使用 */
        /*Singleton s1=Singleton.getInstance();
        Singleton s2=Singleton.getInstance();
        System.out.println(s1==s2);    //输出为true*/    

        Singleton02 s1=Singleton02.getInstance();
        Singleton02 s2=Singleton02.getInstance();
        System.out.println(s1==s2);    //输出为true

        Singleton05 s5=Singleton05.INSTANCE;
        Singleton05 s6=Singleton05.INSTANCE;
        System.out.println(s5==s6);    //输出为true

    }
}

【反射和序列化破解】

/***
 * 使用反射和反序列破解4种单例模式(不包含枚举，枚举基于JVM底层无法破解，最安全)
 * 以懒汉式为例
 */
package cn.sxt.pattern;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;

class Singleton06 implements Serializable{
    private static Singleton06 s;
    private  Singleton06() {//加了抛出异常的私有化构造器，可以防止破解。当线程试图创建多个对象时会抛出异常。一般不用考虑
        if (s!=null) {
            throw new RuntimeException();
        }

    }
    /*private  Singleton06() {//没加抛出异常的私有化构造器

    }*/

    //为啥加同步？因为当线程A执行到s==null后,睡觉去啦,当线程B进来后发现s也是null,会去创建一个对象,当线程A醒来之后也去创建
    //一个新的对象，这样就2个对象，违反单例的定义(即一个单例类有且只有一个示例(对象))
    public static synchronized Singleton06 getInstance() {
        if (s==null) {
            s=new Singleton06();
        }
        return s;
    }

    //防止通过反序列破解单例。意思是在反序列化时直接调用这个方法，通过这个方法去返回我们指导的对象s，而不是创建一个新的对象
    private Object readResolve() throws Exception {//这个方法自己不用调,实现反序列化时自动调用
        return s;
    }
}

public class Test_0422_Singleton2 {
    public static void main(String[] args) throws Exception {
        Singleton06 s1=Singleton06.getInstance();
        Singleton06 s2=Singleton06.getInstance();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1==s2);    //输出为true，s1和s2是同一对象

        /*//通过反射破解单例。通过反射直接调用私有构造器
        Class<Singleton06> clz = (Class<Singleton06>)Class.forName("cn.sxt.pattern.Singleton06");
        Constructor<Singleton06> constructor=clz.getDeclaredConstructor(null);
        constructor.setAccessible(true);//跳过权限检测，访问私有对象
        Singleton06 s3=constructor.newInstance();
        Singleton06 s4=constructor.newInstance();
        System.out.println(s3==s4);//输出为false，显然s3和s4不是同一对象。证明跳过了单例
       */        

        /**序列化：将对象状态转换为字节流的过程，可以将其保存到磁盘文件中或通过网络发送到任何其他程序；
         * 反序列化：从字节流创建对象的相反的过程称为反序列化。而创建的字节流是与平台无关的，在一个平台上序列化的对象可以在
         * 不同的平台上反序列化。
         * */
        //通过反序列化破解单例
        FileOutputStream fos =new FileOutputStream("D:/a.txt");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        oos.writeObject(s1);//把对象s1经由ObjectOutputStream写出到文件 D:/a.txt中
        oos.close();
        fos.close();

        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:/a.txt"));
        Singleton06 s5=(Singleton06)ois.readObject();
        System.out.println(s5);//输出结果与s1和s2不同，证明破解了单例,若加了readResolve()方法，输出结果相同

    }
}

【看看效率】

/***
 * 测试5种单例模式的执行效率
 * 懒汉式：效率最慢
 */
package cn.sxt.pattern;

import java.util.concurrent.CountDownLatch;

public class Test_0422_Singleton3 {
    public static void main(String[] args) throws InterruptedException {
        test();

    }

    public static void test() throws InterruptedException {
        int threadNum=5;
        long start=System.currentTimeMillis();

        /***解决时间不准的问题：主线程(与5个线程独立)可能已经执行完毕到end处了，输出主线程的时间。但是5个线程还有没有
         * 执行完毕的，达不到效果。
         * CountDownLatch类：同步辅助类，是一个统计是否线程结束计数器。 latch:插销 Down:向下
         *  -countDown() 当前线程调用此方法，则计数器减一
         *  -await() 调用此方法会一直阻塞线程，直至计数器为0
         * */
        final CountDownLatch count=new CountDownLatch(threadNum);

        for (int i = 0; i < threadNum; i++) {//创建5个独立线程，让每个线程去执行调用100次单例模式的getInstance()方法
            new Thread(new Runnable() {
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        //Object object=Singleton04.getInstance();
                        Object object2=Singleton05.INSTANCE;
                    }
                    count.countDown();//执行完一个线程 ，调用countDown()方法自动将threadNum(正在执行的线程总数)减一
                }
            }).start();
        }
        count.await();//阻塞main线程，一直等待，循环检测，看其他线程是否执行完才会继续往下

        long end=System.currentTimeMillis();
        System.out.println("总耗时："+(end-start)+"毫秒");
    }
}