Java实现23种设计模式(一):单例模式(重点掌握)

二十三种设计模式分类

设计模式三大分类.jpg

---

一、概述

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

优点

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。

缺点

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

应用场景

1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

---

二、实现

1. 单例模式结构图

单例模式的主要角色如下。

• 单例类：包含一个实例且能自行创建这个实例的类。
• 访问类：使用单例的类。

单例模式

PS:UML结构图可以参考，例子实现并不根据UML图来完成，灵活实现即可；

2. 单例模式实现

2.1. 饿汉式

在JVM加载类阶段就构建对象，适合绝大部分场景，JVM只加载一次类，保证了线程安全；

public class Singleton01 {
    private static Singleton01 instance = new Singleton01();

    private Singleton01() {
    }

    public static Singleton01 getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        Singleton01 singleton01 = Singleton01.getInstance();
        Singleton01 singleton011 = Singleton01.getInstance();
        System.out.println("Compare:" + (singleton01 == singleton011));
    }
}

2.2. 懒汉式

线程不安全，在需要时再构建对象，多个线程同时构建对象时，会构建出多个对象；

public class Singleton02 {
    private static Singleton02 instance;

    private Singleton02(){
    }

    public static Singleton02 getInstance() {
        if (instance == null) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton02();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Singleton02.getInstance().hashCode());
            }).start();
        }
    }
}

2.3. 双重锁检查

使用synchronized类锁限制每次只能有一个线程可以构建新对象，两次判断instance对象是否为null，第一次判断如果为null，则构建新对象；第二次判断是否为null，则是为了防止A线程已经构建完成了对象，避免B线程获得锁后再次构建对象，确保该类只有一个实例；

public class Singleton03 {
    ///volatile防止指令重排序
    private volatile static Singleton03 instance;

    private Singleton03(){
    }

    public static Singleton03 getInstance() {
        if (instance == null) {
            synchronized (Singleton03.class) {
                if (instance == null) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Singleton03();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Singleton03.getInstance().hashCode());
            }).start();
        }
    }
}

2.4. 静态内部类

静态内部类模式，JVM加载静态内部类只会加载一次，加载过程中完成了新对象构建，保证了线程安全，不能解决反序列化问题；

public class Singleton04 {
    private Singleton04(){
    }
    //使用static来修饰一个内部类，则这个内部类就属于外部类本身，而不属于外部类的某个对象
    private static class SingletonHolder{
        private static Singleton04 instance = new Singleton04();
    }

    public static Singleton04 getInstance() {
        return SingletonHolder.instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Singleton04.getInstance().hashCode());
            }).start();
        }
    }
}

2.5. 枚举实现

枚举没有构造函数，所以可解决反序列化的问题，并且保证线程安全；

·public enum Singleton05 {
    /**
     * 单一实例
     */
    INSTANCE;

    public static Singleton05 getInstance() {
        return Singleton05.INSTANCE;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Singleton05 singleton1 = Singleton05.INSTANCE;
        Singleton05 singleton2 = Singleton05.INSTANCE;
        System.out.println("正常情况下，实例化两个实例是否相同：" + (singleton1 == singleton2));
        Constructor<Singleton05> constructor = null;
        constructor = Singleton05.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton05 singleton3 = null;
        singleton3 = constructor.newInstance();
        System.out.println(singleton1 + "\n" + singleton2 + "\n" + singleton3);
        System.out.println("通过反射攻击单例模式情况下，实例化两个实例是否相同：" + (singleton1 == singleton3));
    }
}··