单例模式-系统只有一个实例

最新推荐文章于 2024-08-29 18:08:52 发布

黄名富

最新推荐文章于 2024-08-29 18:08:52 发布

阅读量249

点赞数

分类专栏：设计模式的艺术文章标签：单例模式

本文链接：https://blog.csdn.net/qq_25308331/article/details/131728603

版权

设计模式的艺术专栏收录该内容

43 篇文章 1 订阅

订阅专栏

在基金业务中，基金数量非常多，查询起来非常慢，优化方案是系统每天从数据库把所有的基金信息取出并缓存起来，用户查询的时候直接从缓存里取。而基金缓存信息每天都需要定时更新。

传统的技术方案如下：

图传统技术方案

上述方案有个严重问题，就是FundCacheUtil可以被创建多个实例，这样既会给系统加重负担，同时在不同的FundCacheUtil的实例中，获取的基金信息可能会不一致。

当然，也可以把FundCacheUtil的cacheList设置为静态变量，其方法都设置为静态方法。这样，就能保证系统只存在一个cacheList了。

public class FundCacheUtils {

    private static List<Map<String,Object>> cacheList;

    private FundCacheUtils() {}

    private static void updateCache() {
        //每天7点定时更新
        cacheList = new ArrayList<>();
    }

    public static List<Map<String,Object>> getCacheList() {
        synchronized (FundCacheUtils.class) {
            if (cacheList == null) {
                updateCache();
            }
        }
        return cacheList;
    }

}

public class Client {

    public List<Map<String,Object>> searchFundList() {
        return FundCacheUtils.getCacheList();
    }

    public static void main(String[] args) {
        Client client = new Client();
        List<Map<String, Object>> list1 = client.searchFundList();
        List<Map<String, Object>> list2 = client.searchFundList();
        System.out.println(list1 == list2);
    }

}

这段代码虽然保证了系统只存在一个cacheList，但也存在一个问题：跟新缓存（updateCache）的操作不应该出现在getCacheList中，而是需要确保在调用getCacheList方法之前，已经执行完了updateCache方法。

1 单例模式概述

确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

图单例模式

Singleton: 单例类，只有一个实例。对外提供getInstance()方法来向整个系统提供这个实例。

public class FundCacheStorage {

    volatile private static FundCacheStorage instance = null;

    private List<Map<String,Object>> cacheList;

    private FundCacheStorage() {
        updateCacheList();
    }

    private void updateCacheList() {
        // 每天7点执行一次
        cacheList = new ArrayList<>();
    }

    public List<Map<String,Object>> getCacheList() {
        return this.cacheList;
    }

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

}

public class Client {

    public static void main(String[] args) {
        FundCacheStorage instance1 = FundCacheStorage.getInstance();
        List<Map<String, Object>> cacheList1 = instance1.getCacheList();

        FundCacheStorage instance2 = FundCacheStorage.getInstance();
        List<Map<String, Object>> cacheList2 = instance2.getCacheList();

        System.out.println(cacheList2 == cacheList1);
    }

}

1.1 饿汉式与懒汉式

饿汉式：定义静态变量的时候实例化单例类，在类加载时自行实例化。

private static Singleton instance = new Singleton();

懒汉式：在类加载时并不自行实例化，在需要的时候再加载实例。这种技术又称为延迟加载(Lazy Load)技术。

懒汉式获取实例的时候，需要使用双重检测锁定，来避免多线程会创建不同的实例。

模式	优点	缺点
饿汉式	无须考虑多线程访问问题，可以确保实例的唯一性。从调用速度和反应时间角度来讲，效率优先于懒汉式。	在类加载时该对象就需要创建，从资源利用效率角度来讲，劣于懒汉式。在系统加载时需要创建饿汉式单例对象，加载时间可能会比较长。
懒汉式	1）在第一次使用时才创建，不会一直占用系统资源。	1）必须处理好多线程同时访问问题。

表饿汉式与懒汉式优缺点

1.2 按需初始化持有者(IoDH)

全称为Initialization on Demand Holder，简称为IoDh技术，实现IoDH时，需在单例类中增加一个静态内部类，在该内部内中创建实例对象，再将该实例对象通过getInstance()方法返回给外部使用。

public class FundCacheStorage2 {

    private List<Map<String,Object>> cacheList;

    private FundCacheStorage2() {}

    private static class HolderClass {
        private final static FundCacheStorage2 instance = new FundCacheStorage2();
    }

    public static FundCacheStorage2 getInstance() {
        return HolderClass.instance;
    }

    private void updateCacheList() {
        // 每天7点执行一次
        cacheList = new ArrayList<>();
    }

    public List<Map<String,Object>> getCacheList() {
        return this.cacheList;
    }

}

IoDH 技术由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有被任何线程锁定，因此其性能不会造成任何影响。

通过使用IoDH，既可以实现延迟加载，又可以保证线程安全，不影响系统性能。因此，IoDH不失为一种最好的Java语言单例模式的实现方式。但是该技术与编程语言本身的特性相关，很多面向对象语言不支持IoDH.