单例模式-全网最详解读

最新推荐文章于 2023-08-02 23:20:44 发布

李小立Flag

最新推荐文章于 2023-08-02 23:20:44 发布

阅读量666

点赞数 2

分类专栏：设计模式详谈文章标签： Java 设计模式单例模式详谈设计模式

本文链接：https://blog.csdn.net/qq_44614710/article/details/116528620

版权

设计模式详谈专栏收录该内容

2 篇文章 0 订阅

订阅专栏

总结目录

简介
1.饿汉模式
2.懒汉模式
3.防止单例的破坏
- 3.1 反射会破坏单例模式

简介

单例模式是设计模式中最简单且常用的设计模式。是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。Spring 框架应用中 ApplicationContext；数据库的连接池也都是单例形式。
特点：

在Java应用中，单例模式能保证在一个JVM中，该对象只有一个实例存在
构造器必须是私有的，外部类无法通过调用构造器方法创建该实例
没有公开的set方法，外部类无法调用set方法创建该实例
提供一个公开的方法获取唯一的这个实例

优势：

某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销
省去了new操作符，降低了系统内存的使用频率，减轻GC压力
系统中某些类，如spring里的controller，控制着处理流程，如果该类可以创建多个的话，系统完全乱了
避免了对资源的重复占用
1.饿汉模式

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，因为在线程还没出现以前就是实例化了，不可能存在访问安全问题。
优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。
缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，占着茅坑不拉屎。
Spring 中 IOC 容器 ApplicationContext 本身就是典型的饿汉式单例。
来看饿汉模式代码：

public class HungrySingleton {
   /**
    * 构造器私有化
    */
   private HungrySingleton() {}

   /**
    * 静态初始化
    */
   private static final HungrySingleton hungrySingleton=new HungrySingleton();

   /**
    * 提供对外的访问方法
    */
   public static HungrySingleton getInstance(){
       return hungrySingleton;
   }
}

以空间换时间，故不存在线程安全问题。

2.懒汉模式

懒汉式单例模式：被外部类调用的时候内部类才会加载

2.1 简单实现

先看一下懒汉模式的简单实现，思考一下有什么弊端。

public class LazySimpleSingleton {
 /**
  * 构造器私有化
  */
 private LazySimpleSingleton() {}

 /**
  * 静态代码，使用公共内存区域
  */
 private static LazySimpleSingleton lazy=null;

 /**
  * 提供对外的访问方法
  */
 public static LazySimpleSingleton getInstance(){
     if(lazy==null){
         lazy=new LazySimpleSingleton();
     }
     return lazy;
 }
}

有没有同学思考过？这样的写法是线程不安全的。
我们来设想一个极端的例子，假设lazy没有被实例化，多线程环境下10个线程同时进入if判断如下图：在这里插入图片描述
此时多个线程都会执行到new LazySimpleSingleton()方法，产生多个实例，与单例模式的概念相违背，所以说它线程不安全。
以时间换空间，在多线程环境下存在风险

2.2 线程安全-懒汉模式

所以，我们需要优化代码，使得懒汉式单例在多线程环境下安全

/**
     * 只需要修改get提供对外的访问方法 
     * 加上synchronized 关键字，使这个方法变成线程同步方法
     */
    public static synchronized LazySingleton getInstance(){
        if(lazy==null){
            lazy=new LazySingleton();
        }
        return lazy;
    }

加上synchronized 关键字后，会阻塞其他线程调用，防止多个线程同时调用。
虽然目前线程安全了，但在线程数量较多时，会导致大量的线程阻塞，程序的性能必定严重下滑。

2.3 双重锁检查-懒汉模式

那么，有没有一种更好的方式，既兼顾线程安全又提升程序性能呢？答案是肯定的。我们来看双重检查锁的单例模式

public class LazyDoubleLockCheckSingleton {
    /**
     * 构造器私有化
     */
    private LazyDoubleLockCheckSingleton() {}

    /**
     * 静态代码，使用公共内存区域
     */
    private static LazyDoubleLockCheckSingleton lazy=null;

    /**
     * 提供对外的访问方法
     */
    public static LazyDoubleLockCheckSingleton getInstance(){
       //先判断lazy是否为实例化，没有的话上锁，如果有实例化对象就不必加锁提高效率。
        if(lazy==null){
            //这里可能同时有多个线程等待锁,例如线程1获得锁，初始化没完成，lazy==null，线程2.3会进入等待锁。
           synchronized (LazyDoubleLockCheckSingleton.class){
               //二次判断的原因，例如线程1执行完成。已经实例化lazy
               //线程2获得锁，如过没加判断会二次实例化对象。
               if(lazy==null){
                   lazy=new LazyDoubleLockCheckSingleton();
               }
           }
        }
        return lazy;
    }

2.4 静态内部类-懒汉模式

双重锁虽然保证了线程的绝对安全，但是 synchronized 关键字，总归是要上锁，对程序性能还是存在一定影响的。所以从类初始化角度来考虑，看下面的代码，采用静态内部类的方式：

public class LazyStaticClassSingleton {

    /**
     * 构造器私有化
     */
    private LazyStaticClassSingleton() {}

    /**
     * 提供对外的访问方法
     * static 是为了使单例的空间共享 final 保证这个方法不会被重写，重载
     */
    public static final LazyStaticClassSingleton getInstance(){
        return LazyStaticClass.Lazy;
    }

    /**
     *  默认认不加载，静态内部类的机制
     */
    private static class  LazyStaticClass{
        private static final LazyStaticClassSingleton Lazy=new LazyStaticClassSingleton();
    }
}

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化，故而不占内存。 LazyStaticClassSingleton 第一次被加载时，并不需要去加载LazyStaticClass，只有当getInstance()方法第一次被调用时，才会去初始化,第一次调用getInstance()方法会导致虚拟机加载LazyStaticClass类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

3.防止单例的破坏

3.1 反射会破坏单例模式

了解反射的同学可能发现了（点击查看反射详解），我们上面的代码构造方法里面没有做任何处理。这样的话可以通过反射去破坏单例模式，产生多个实例。
我们以静态内部类 请看下列代码

/**
     * 反射破坏单例模式，产生多个实例
     */
    public static void reflectDestroy() throws Exception{

        //获取class对象
        Class<?> clazz= LazyStaticClassSingleton.class;
        //获取私有构造器
        Constructor<?> constructor = clazz.getDeclaredConstructor(null);
        //设置为true才能获取私有属性
        constructor.setAccessible(true);


        //暴力初始化
         LazyStaticClassSingleton o = (LazyStaticClassSingleton)constructor.newInstance();

        //静态内部类单例模式
        LazyStaticClassSingleton singletion = LazyStaticClassSingleton.getInstance();


        System.err.println(singletion);
        System.err.println(o);
        System.err.println(o==singletion);

    }

在这里插入图片描述

可以看到两个对象地址不一致，显然，是创建了两个不同的实例。单例模式被破坏

现在，我们在其构造方法中做一些限制，一旦出现多次重复创建，则直接抛出异常。来看优化后的代码

/**
     * 构造器私有化
     * 默认使用 LazyStaticClassSingleton 的时候，会先初始化内部类
     */
    private LazyStaticClassSingleton() {
        if(LazyStaticClass.Lazy!=null){
            throw new RuntimeException("请通过getInstance创建单例模式");
        }
    }

再运行测试代码，会得到以下结果：
在这里插入图片描述
版权声明：本文为博主原创文章，未经博主允许不得转载 https://blog.csdn.net/qq_44614710/article/details/116705838

李小立Flag

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
6
评论
单例模式-全网最详解读

总结目录简介1.饿汉模式2.懒汉模式2.1 简单实现2.2 线程安全的懒汉模式2.3 双重锁检查懒汉模式简介单例模式是设计模式中最简单且常用的设计模式。是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。Spring 框架应用中 ApplicationContext；数据库的连接池也都是单例形式。1.饿汉模式饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，因为在线程还没出现以前就是实例化了，不可能存在访问安全问题。优点：没有加任何的锁、执行效率比较高，在
复制链接

扫一扫