设计模式学习---单例模式-低调大师

设计模式学习---单例模式

2020-02-18 646

单例模式---对于整个系统只需要一个实体就能完成工作的情况下，我们系统只需要一个实体并且保证只有一个实例，避免造成资源浪费

1.懒汉

懒汉模式是在需要用到该实例的时候才进行实例化

优点:节约资源，在需要用到该实例的时候才初始化

缺点:线程非安全，并发访问情况下，有可能多次实例化，并且每次实例化都覆盖上一次的实例

public class Singleton {

    private static Singleton SINGLETON;

    private Singleton(){}

    public static Singleton getInstance(){
        if(Singleton.SINGLETON == null);
            Singleton.SINGLETON = new Singleton();
        return SINGLETON;
    }

}

2.饿汉

饿汉单例模式在类加载的时候就实例化

优点：安全，不存在并发创建多实例问题

缺点：容易造成资源浪费，一直占用着资源且无法回收

public class Singleton {

    private static final Singleton SINGLETON = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return SINGLETON;
    }

}

3.懒汉模式(方法加锁)

这种模式在获取实例的时候添加synchronize同步锁能避免多并发情况下造成创建多实例问题

优点:具有懒汉模式的节约资源优点，且方法加锁情况下避免了多并发创建多次实例的情况

确定:方法锁消耗性能比较大，必须是第一访问完整个方法才到第二次访问进入

public class Singleton {

    private static Singleton SINGLETON;

    private Singleton(){}

    public synchronized static Singleton getInstance(){
        if(Singleton.SINGLETON == null);
            Singleton.SINGLETON = new Singleton();
        return SINGLETON;
    }
}

4.双重锁校验(推荐)

双重锁校验是优化了方发锁的方式而来，优化啊了多并发情况下性能低下的结果

优点：保证了线程安全情况下，节约资源且访问性能高

public class Singleton {

    private static Singleton SINGLETON;

    private Singleton(){}

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

进入方法体之后首先判断了实例是否存在，如果存在，则直接返回实例，否则加锁执行多一次判断，如果为null再实例化。因为第一次判断和加锁之间，对象可能已经实例化，所以加锁之后再判断一次，避免多次创建。但是这种方式还有点缺陷，synchronized关键字可以保证多线程情况下同步问题，如果是多核计算机(现在绝大部分都是多核计算机)情况下，还会有一个指令重排的问题所以我们需要用volatile 来修饰SINGLETON，最后改造成下面代码

public class Singleton {

    private volatile static Singleton SINGLETON;

    private Singleton(){}

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

5.静态内部类

静态内部类是在调用的时候才会进行加载，是懒汉模式另外一种实现方式

public class Singleton {

    private Singleton(){}

    public static Singleton getInstance(){
        return Instance.singleton;
    }

    private static class Instance{
        private static final Singleton singleton = new Singleton();
    }
}

6.枚举

枚举为最优的单例模式实现方案，因为可以防反射暴力创建对象，也可以避免序列化问题，下面先放了一个简单的例子，

public enum SingletonEnum {

    SINGLETON;

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static SingletonEnum getInstance(){
        return SINGLETON;
    }

}

看一下使用方式

public static void main(String[] args) {
    SingletonEnum.SINGLETON.setName("name1");
    System.out.println(SingletonEnum.SINGLETON.getName());
}

输出结果，由此可见 SingletonEnum.SINGLETON 时调用的都是同一个实例

下面我们看看枚举类型防放射暴力创建实例

我们用之前静态内部类的那个代码来比较

public static void main(String[] args) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException, InstantiationException {
    // 反射获取构造器
    Constructor<Singleton> singletonConstructor = Singleton.class.getDeclaredConstructor();
    // 通过构造器创建对象
    Singleton singleton1 = singletonConstructor.newInstance();
    // 通过我们单例获取实例的接口获取实例
    Singleton singleton2 = Singleton.getInstance();
    // 下面结果为false，证明是2个不一样的实例，甚至都不用调用构造器的 setAccessible() 就能成功新建一个实例
    System.out.println(singleton1 == singleton2);
}

接下来再看看枚举

public static void main(String[] args) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException, InstantiationException {
    // 反射获取构造器
    Constructor<SingletonEnum> singletonEnumConstructor = SingletonEnum.class.getDeclaredConstructor();
    // 通过构造器创建对象
    SingletonEnum singletonEnum1 = singletonEnumConstructor.newInstance();
    // 获取单例
    SingletonEnum singletonEnum2 = SingletonEnum.SINGLETON;
    // 下面结果为false，证明是2个不一样的实例，甚至都不用调用构造器的 setAccessible() 就能成功新建一个实例
    System.out.println(singletonEnum1 == singletonEnum2);
}

这时候报是报了个java.lang.NoSuchMethodException，原因是因为枚举类型没有无参构造

下面我们进入debug模式可以看到只有一个带一个String参数和一个int参数的构造方法

所以改造成

public static void main(String[] args) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException, InstantiationException {
    // 反射获取构造器
    Constructor<SingletonEnum> singletonEnumConstructor = SingletonEnum.class.getDeclaredConstructor(String.class,int.class);
    // 通过构造器创建对象
    SingletonEnum singletonEnum1 = singletonEnumConstructor.newInstance("",1);
    // 获取单例
    SingletonEnum singletonEnum2 = SingletonEnum.SINGLETON;
    // 下面结果为false，证明是2个不一样的实例，甚至都不用调用构造器的 setAccessible() 就能成功新建一个实例
    System.out.println(singletonEnum1 == singletonEnum2);
}

但是改过来之后报了个 java.lang.IllegalAccessException 非法访问异常

原因是如果实例化的对象是个枚举类型，就会抛出这个异常，这说明枚举类型天生就是单例的

public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
           IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, null, modifiers);
        }
    }
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}

if ((clazz.getModifiers() & Modifier.ENUM) != 0)
    throw new IllegalArgumentException("Cannot reflectively create enum objects");

序列化与反序列化，如果我们实体需要储存到程序以外的存储媒介，当再次获取时候，这个实例并非我们最开始的实例

序列化的时候实体类必须实现 Serializable

public class Singleton implements Serializable{}

public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
    // 通过获取实例接口获取实例
    Singleton singleton1 = Singleton.getInstance();
    // 创建输出流并且输出到文件
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\singleton\\singleton.txt"));
    oos.writeObject(singleton1);

    // 创建输入流并且反序列化实例
    ObjectInputStream ios = new ObjectInputStream(new FileInputStream("D:\\singleton\\singleton.txt"));
    Singleton singleton2 = (Singleton) ios.readObject();
    oos.close();
    ios.close();
    System.out.println(singleton1 == singleton2);
}

序列化前后的对象结果对比，不是同一个实例

再看看枚举类型

public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
    SingletonEnum singletonEnum1 = SingletonEnum.SINGLETON;
    // 创建输出流并且输出到文件
    ObjectOutputStream oosE = new ObjectOutputStream(new FileOutputStream("D:\\singleton\\singletonE.txt"));
    oosE.writeObject(singletonEnum1);

    // 创建输入流并且反序列化实例
    ObjectInputStream iosE = new ObjectInputStream(new FileInputStream("D:\\singleton\\singletonE.txt"));
    SingletonEnum singletonEnum2 = (SingletonEnum) iosE.readObject();
    oosE.close();
    iosE.close();
    System.out.println(singletonEnum1 == singletonEnum2);
}

序列化前后的对象是一致的，没有被破坏

所以单例的最优方案是枚举，其他方法都会因为反射或者序列化破坏了整个系统只有一个实例的原则，当然根据业务要求选择一种比较合适目前开发团队的方案也很重要

微信关注我们

原文链接：https://my.oschina.net/u/2925037/blog/3167775

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

java源码学习---HashMap

开门见山，直接干 HashMap是java常用的一个集合，每个元素的key经过哈希算法后储存在链表或红黑树的一种键值对数据集合（JDK1.8）从HashMap新增元素说起 map.put("key","value"); 这是我们日常向HashMap插入元素的其中一种方式，put(k,v)的源码 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } put()会再调用一个putVal()，但是在这之前key会通过hash()计算出对应位置的值，真正的put操作，就是从这里开始 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = r...

2020-02-14

489

SOP 3.1.0 发布，本次更新内容如下：新增路由监控功能新增路由拦截器 doc 优化负载均衡策略本次更新重点内容是路由监控功能，网关统计每个接口的最大耗时，最小耗时，平均耗时，总调用次数，成功次数，失败次数。该功能是通过路由拦截器实现的。登录admin后台可查看监控情况关于 SOP SOP(Simple Open Platform) 一个开放平台解决方案项目，基于 Spring Cloud 实现，目标是能够让用户快速得搭建起自己的开放平台。 SOP 提供了两种接口调用方式，分别是：支付宝开放平台的调用方式和淘宝开放平台的调用方式。通过简单的配置后，你的项目就具备了和支付宝开放平台的一样的接口提供能力。 SOP 封装了开放平台大部分功能包括：签名验证、统一异常处理、统一返回内容、业务参数验证（JSR-303）、秘钥管理等，未来还会实现更多功能。项目特点接入方式简单，与老项目不冲突，老项目注册到注册中心，然后在方法上加上注解即可。架构松耦合，业务代码实现在各自微服务上，SOP 不参与业务实现，这也是 Spring Cloud 微服务体系带来的好处。扩展简单，开放平...

2020-02-19

729

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。