Java 设计模式——单例模式

一、简介

属于创建型模式，提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。
这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

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

二、作用

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

关键代码：构造函数是私有的。

优点：

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

缺点：

1、没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
2、如果实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，这将导致对象状态的丢失。

三、实现方式

说明

实现方式：根据需求场景，可分为2大类、6种实现方式。
两大类：饿汉式，懒汉式
饿汉式：单例创建时机不可控，即类加载时 自动创建 单例
懒汉式：单例创建时机可控，即有需要时，才手动创建 单例

（1）第一种方式

懒汉式 线程不安全

/**
 *  不支持多线程，因为没有加锁 synchronized
 */
public class SingletonI {

    //声明单例的引用
    private static SingletonI instance;  
    //创建私有构造函数，防止创建新的实例
    private SingletonI (){}  
    //创建单例
    public static SingletonI getInstance() {  
        //判断实例是否为空
        if (instance == null) {
            //创建实例
            instance = new SingletonI();
        }
        //对外提供的唯一实例
        return instance;  
    } 
}

（2）第二种方式

懒汉式 线程安全

/**
 *  在第一种方式的基础上添加了synchronized
 *  必须加锁 synchronized 才能保证线程安全，
 *   缺点：每次访问都要进行线程同步（即 调用synchronized锁)，造成过多的同步开销（加锁 = 耗时、耗能）
 */
public class SingletonII {
    //声明单例的引用
    private static SingletonII instance;
    //创建私有构造函数，防止创建新的实例
    private SingletonII (){}  
    //添加了synchronized 在多线程下保证线程安全
    public static synchronized SingletonII getInstance() {  
        if (instance == null) {  
            instance = new SingletonII();  
        }  
        return instance;  
    }
}

（3）第三种方式

饿汉式 线程安全

/**
 *  单例对象 要求初始化速度快 & 占用内存小单例对象 要求初始化速度快 & 占用内存小
 *  优点：没有加锁，执行效率会提高。
 *  缺点：类加载时就初始化，浪费内存。
 */
public class SingletonIII {

    //加载该类时，立马创建实例
    private static SingletonIII instance = new SingletonIII();  
    //创建私有构造函数，防止创建新的实例
    private SingletonIII (){}  
    //提供一个访问该实例的访问点
    public static SingletonIII getInstance() {  
        return instance;  
    }
}

（4）第四种方式

懒汉式 双检锁/双重校验锁

/**
 *   这种方式采用双锁机制，安全且在多线程情况下能保持高性能
 *   缺点：实现方式较复杂
 */
public class SingletonIV {
    //声明单例的引用
    private static SingletonIV instance;
    //创建私有构造函数，防止创建新的实例
    private SingletonIV() {}
    //创建线程安全的单例
    public static SingletonIV getInstance() {
        //判断是否存在单例
        if(instance==null) {
            //保持只有一个线程执行
            synchronized(SingletonIV.class) {
                //再次判断单例是否被创建（防止其他线程已经创建而导致再次创建）
                if(instance==null) {
                    instance=new SingletonIV();
                }
            }
        }
        return instance;
    }

}

（5）第五种方式

懒汉式 登记式/静态内部类

/**
 *  这种方式能达到双检锁方式一样的功效，但实现更简单
 */
public class SingletonV {
    //创建静态内部类、创建单例
    private static class SingletonHolder {  
        private static final SingletonV INSTANCE = new SingletonV();  
    }  
    //创建私有构造函数，防止创建新的实例
    private SingletonV (){}  
    //提供一个外部访问点来获取单例
    public static final SingletonV getInstance() {  
        return SingletonHolder.INSTANCE;  
    }
}

（6）第六种方式

枚举

/**
 *  创建单例、线程安全、实现简洁的需求
 */
public enum SingletonVI {
     //定义1个枚举的元素，即为单例类的1个实例
    INSTANCE;  
    // 隐藏了1个空的、私有的 构造方法
    // private Singleton () {}

    // 获取单例的方式：
    //Singleton singleton = Singleton.INSTANCE;
}

般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。
只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。
如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。
如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

四、测试

测试调用方式

    //用于测试，在每个单例添加如下方法
    public void showData() {
        System.out.println(getClass());
    }

测试类

public class TestSingleton {
    public static void main(String[] args) {
        //调用方式
        SingletonI instance = SingletonI.getInstance();
        SingletonII instanceII = SingletonII.getInstance();
        SingletonIII instanceIII = SingletonIII.getInstance();
        SingletonIV instanceIV = SingletonIV.getInstance();
        SingletonV instanceV = SingletonV.getInstance();
        SingletonVI instanceVI = SingletonVI.INSTANCE;
        instance.showData();
        instanceII.showData();
        instanceIII.showData();
        instanceIV.showData();
        instanceV.showData();
        instanceVI.showData();
    }
}

结果：除了枚举，其他单例的调用方式都差不多一致

image.png

测试单例模式效果

举例：假设一家人都在使用一张信用卡(单例对象)，消费与还款都在同一张信用卡上。

/**
 * 创建信用卡单例
 * 这里采用枚举实现方式 
 */
public enum Card {
    INSTANCE;

        //初始金额
    private int Amount = 20000;
    /**
     * 消费
     */
    public void consume(int sum) {
        System.out.println("消费了"+sum);
        this.Amount-=sum;
    }
    /**
     *  还款
     */
    public void repayment(int sum) {
        System.out.println("还款了"+sum);
        this.Amount+=sum;
    }
    /**
     *  查询
     */
    public void query() {
        System.out.println("信用卡额度："+Amount);
    }
}

测试类：

public class TestSingleton {
    public static void main(String[] args) {
        //测试是否实现单例
        //举例：假设一家人都在使用一张信用卡(单例对象)，消费与还款都在同一张信用卡上。
        //步骤一：创建一张信用卡实例（单例） 查询信用卡额度
        Card card = Card.INSTANCE;
        card.query();
        //假设你在学校（另一个类中）消费了5000
        System.out.println("我");
        Card card1 = Card.INSTANCE;
        card1.consume(5000);    
        card1.query();
        //假设母亲在家里（另一个类中）消费了7000
        System.out.println("母亲");
        Card card2 = Card.INSTANCE;
        card2.consume(7000);    
        card2.query();
        //假设父亲公司（另一个类中）还款了7000
        System.out.println("父亲");
        Card card3 = Card.INSTANCE;
        card3.repayment(7000);  
        //最后查询信用卡的额度
        card.query();
        //始终使用的都是同一张卡
    }
}   

效果：

image.png

五、源码地址

https://github.com/DayorNight/DesignPattern

六、参考文档

https://www.jianshu.com/p/b8c578b07fbc
http://www.runoob.com/design-pattern/singleton-pattern.html

七、内容推荐

CSDN地址：https://blog.csdn.net/cs_lwb/article/details/83864571

如果你觉得我写的不错或者对您有所帮助的话。不妨顶一个，也方便以后复习
您的每个举动都是对我莫大的支持

谢谢了！！！ image