面试常问单例模式？8种写法？这篇文章给你答案！

最新推荐文章于 2022-02-17 11:31:05 发布

柚子-youzi

最新推荐文章于 2022-02-17 11:31:05 发布

阅读量174

点赞数 1

分类专栏： Java学习 Java Java面试题文章标签：多线程 java 设计模式面试编程语言

本文链接：https://blog.csdn.net/weixin_48655626/article/details/110481373

版权

Java 同时被 3 个专栏收录

117 篇文章 1 订阅

订阅专栏

Java学习

112 篇文章 0 订阅

订阅专栏

Java面试题

37 篇文章 2 订阅

订阅专栏

1. 单例模式常见问题

为什么要有单例模式

单例模式是一种设计模式，它限制了实例化一个对象的行为，始终至多只有一个实例。当只需要一个对象来协调整个系统的操作时，这种模式就非常有用.它描述了如何解决重复出现的设计问题，比如我们项目中的配置工具类,日志工具类等等。

如何设计单例模式 ?

单例类如何控制其实例化
如何确保只有一个实例

通过一下措施解决这些问题：

private构造函数,类的实例话不对外开放,由自己内部来完成这个操作,确保永远不会从类外部实例化类,避免外部随意new出来新的实例。

该实例通常存储为私有静态变量，提供一个静态方法，返回对实例的引用。如果是在多线程环境下则用锁或者内部类来解决线程安全性问题。

记得点赞收藏加关注哦，需要下载PDF版本和获取更多知识点、面试题的朋友可以点一点下方链接免费领取

链接：点这里！！！ 799215493 暗号：CSDN

在这里插入图片描述

2. 单例类有哪些特点 ?

私有构造函数

它将阻止从类外部实例化新对象

它应该只有一个实例

这是通过在类中提供实例来方法完成的,阻止外部类或子类来创建实例。这是通过在java中使构造函数私有来完成的，这样任何类都不能访问构造函数，因此无法实例化它。

单****实例应该是全局可访问的

单例类的实例应该是全局可访问的，以便每个类都可以使用它。在Java中，它是通过使实例的访问说明符为public来完成的。

节省内存,减少GC

因为是全局至多只有一个实例，避免了到处new对象,造成浪费内存,以及GC，有了单例模式可以避免这些问题

3. 单例模式8种写法

下面由我给大家介绍8种单例模式的写法,各有千秋,存在即合理，通过自己的使用场景选一款使用即可。我们选择单例模式时的挑选标准或者说评估一种单例模式写法的优劣时通常会根据以下两种因素来衡量:

在多线程环境下行为是否线程安全
饿汉以及懒汉
编码是否优雅(理解起来是否比较直观)

1. 饿汉式线程安全的

public class SingleTon{

	private static final SingleTon INSTANCE = new SingleTon();

	private SingleTon(){ }

	public static SingleTon getInstance(){
		return INSTANCE;
	}
	public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
    }

}

这种写法是非常简单实用的，值得推荐，唯一缺点就是懒汉式的，也就是说不管是否需要用到这个方法，当类加载的时候都会生成一个对象。

除此之外，这种写法是线程安全的。类加载到内存后，就实例化一个单例，JVM保证线程安全，

2. 饿汉式线程安全(变种写法)。

public class SingleTon{

	private static final SingleTon INSTANCE ;

	static {
	    INSTANCE = new SingleTon(); 
	}

	private SingleTon(){}

	public static SingleTon getInstance(){
		return INSTANCE;
	}
        public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
    }

}

3. 懒汉式线程不安全。

public class SingleTon{

	private static  SingleTon instance ;

	private SingleTon(){}

	public static SingleTon getInstance(){
            if(instance == null){
                instance = new SingleTon();
            }
            return instance;
	}

	public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
        
        // 通过开启100个线程 比较是否是相同对象
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

这种写法虽然达到了按需初始化的目的，但却带来线程不安全的问题，至于为什么在并发情况下上述的例子是不安全的呢 ?

   // 通过开启100个线程 比较是否是相同对象
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }

为了使效果更直观一点我们对getInstance 方法稍做修改,每个线程进入之后休眠一毫秒，这样做的目的是为了每个线程都尽可能获得cpu时间片去执行。代码如下

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

上述的单例写法，我们是可以创造出多个实例的，至于为什么在这里要稍微解释一下,这里涉及了同步问题

造成线程不安全的原因：

当并发访问的时候，第一个调用getInstance方法的线程t1，在判断完singleton是null的时候，线程A就进入了if块准备创造实例，但是同时另外一个线程B在线程A还未创造出实例之前，就又进行了singleton是否为null的判断，这时singleton依然为null，所以线程B也会进入if块去创造实例，这时问题就出来了，有两个线程都进入了if块去创造实例，结果就造成单例模式并非单例。

注:这里通过休眠一毫秒来模拟线程挂起,为初始化完instance

为了解决这个问题,我们可以采取加锁措施,所以有了下面这种写法

4. 懒汉式线程安全(粗粒度Synchronized)。

public class SingleTon{

	private static  SingleTon instance ;

	private SingleTon(){}

	public static SingleTon synchronized getInstance(){
	    if(instance == null){
                instance = new SingleTon();
	    }
	    return instance;
	}

	public static void main(String[] args) {
	    SingleTon instance1 = SingleTon.getInstance();
	    SingleTon instance2 = SingleTon.getInstance();
	    System.out.println(instance1 == instance2);
            // 通过开启100个线程 比较是否是相同对象
            for(int i=0;i<100;i++){
                new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

由于第三种方式出现了线程不安全的问题,所以对getInstance方法加了synchronized来保证多线程环境下的线程安全性问题，这种做法虽解决了多线程问题但是效率比较低。

因为锁住了整个方法，其他进入的现成都只能阻塞等待了，这样会造成很多无谓的等待。

于是可能有人会想到可不可以让锁的粒度更细一点,只锁住相关代码块可否？所以有了第五种写法。

5. 懒汉式线程不安全(synchronized代码块)

public class SingleTon{

	private static  SingleTon instance ;

	private SingleTon(){}

	public static SingleTon getInstance(){
	    if(insatnce == null){
	        synchronied(SingleTon.class){
                    instance = new SingleTon();
	        }
	    }
	    return instance;
	}

	public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
        
        // 通过开启100个线程 比较是否是相同对象
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

当并发访问的时候，第一个调用getInstance方法的线程t1，在判断完instance是null的时候，线程A就进入了if块并且持有了synchronized锁，但是同时另外一个线程t2在线程t1还未创造出实例之前，就又进行了instance是否为null的判断，这时instance依然为null，所以线程t2也会进入if块去创造实例，他会在synchronized代码外面阻塞等待，直到t1释放锁，这时问题就出来了，有两个线程都实例化了新的对象。

造成这个问题的原因就是线程进入了if块并且在等待synchronized锁的过程中有可能上一个线程已经创建了实例,所以进入synchronized代码块之后还需要在判断一次,于是有了下面这种双重检验锁的写法。

6. 懒汉式线程安全(双重检验加锁)

public class SingleTon{

	private static  volatile SingleTon instance ;

	private SingleTon(){}

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

	public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
        
        // 通过开启100个线程 比较是否是相同对象
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

这种写法基本趋于完美了，但是可能需要对一下几点需要进行解释：

第一个判空(外层)的作用？
第二个判空(内层)的作用？
为什么变量修饰为volatile ？

第一个判空(外层)的作用

首先，思考一下可不可以去掉最外层的判断？答案是：可以

其实仔细观察之后会发现最外层的判断跟能否线程安全正确生成单例无关！！！

它的作用是避免每次进来都要加锁或者等待锁，有了同步代码块之外的判断之后省了很多事，当我们的单例类实例化一个单例之后其他后续的所有请求都没必要在进入同步代码块继续往下执行了，直接返回我们曾生成的实例即可，也就是实例还未创建时才进行同步，否则就直接返回，这样就节省了很多无谓的线程等待时间，所以最外的判断可以认为是对提升性能有帮助。

第二个判空(内层)的作用

假设我们去掉同步块中的是否为null的判断，有这样一种情况，A线程和B线程都在同步块外面判断了instance为null，结果t1线程首先获得了线程锁，进入了同步块，然后t1线程会创造一个实例，此时instance已经被赋予了实例，t1线程退出同步块，直接返回了第一个创造的实例，此时t2线程获得线程锁，也进入同步块，此时t1线程其实已经创造好了实例，t2线程正常情况应该直接返回的，但是因为同步块里没有判断是否为null，直接就是一条创建实例的语句，所以t2线程也会创造一个实例返回，此时就造成创造了多个实例的情况。

为什么变量修饰为volatile

因为虚拟机在执行创建实例的这一步操作的时候，其实是分了好几步去进行的，也就是说创建一个新的对象并非是原子性操作。在有些JVM中上述做法是没有问题的，但是有些情况下是会造成莫名的错误。

首先要明白在JVM创建新的对象时，主要要经过三步。

1.分配内存

2.初始化构造器

3.将对象指向分配的内存的地址

因为仅仅一个new 新实例的操作就涉及三个子操作，所以生成对象的操作不是原子操作

而实际情况是，JVM会对以上三个指令进行调优，其中有一项就是调整指令的执行顺序(该操作由JIT编译器来完成)。

所以，在指令被排序的情况下可能会出现问题，假如 2和3的步骤是相反的，先将分配好的内存地址指给instance，然后再进行初始化构造器，这时候后面的线程去请求getInstance方法时，会认为instance对象已经实例化了，直接返回一个引用。

如果这时还没进行构造器初始化并且这个线程使用了instance的话，则会出现线程会指向一个未初始化构造器的对象现象，从而发生错误。

7. 静态内部类的方式(基本完美了)

public class SingleTon{

	public static SingleTon getInstance(){
	    return StaticSingleTon.instance;
	}
	private static class StaticSingleTon{
            private static final SingleTon instance = new SingleTon();
	}
	public static void main(String[] args) {
        SingleTon instance1 = SingleTon.getInstance();
        SingleTon instance2 = SingleTon.getInstance();
        System.out.println(instance1 == instance2);
        
        // 通过开启100个线程 比较是否是相同对象
        for(int i=0;i<100;i++){
             new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

因为一个类的静态属性只会在第一次加载类时初始化，这是JVM帮我们保证的，所以我们无需担心并发访问的问题。所以在初始化进行一半的时候，别的线程是无法使用的，因为JVM会帮我们强行同步这个过程。

另外由于静态变量只初始化一次，所以singleton仍然是单例的。

8. 枚举类型的单例模式(太完美以至于。。。)

public Enum SingleTon{
    
    INSTANCE;
    public static void main(String[] args) {
         // 通过开启100个线程 比较是否是相同对象
        for(int i=0;i<100;i++){
            new Thread(()->
                System.out.println(SingleTon.getInstance().hashCode())
            ).start();
        }
        
    }

}

这种写法从语法上看来是完美的,他解决了上面7种写法都有的问题,就是我们可以通过反射可以生成新的实例。

但是枚举的这种写法是无法通过反射来生成新的实例,因为枚举没有public构造方法。

最后

感谢大家看到这里，文章有不足，欢迎大家指出；如果你觉得写得不错，那就给我一个赞吧。

我这里准备了一线大厂面试资料和我原创的超硬核PDF技术文档，以及我为大家精心准备的多套简历模板（不断更新中），希望大家都能找到心仪的工作！

有需要的朋友可以点一点下方链接免费领取

链接：点这里！！！ 799215493 暗号：CSDN

在这里插入图片描述

柚子-youzi

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
面试常问单例模式？8种写法？这篇文章给你答案！

1. 单例模式常见问题为什么要有单例模式单例模式是一种设计模式，它限制了实例化一个对象的行为，始终至多只有一个实例。当只需要一个对象来协调整个系统的操作时，这种模式就非常有用.它描述了如何解决重复出现的设计问题，比如我们项目中的配置工具类,日志工具类等等。如何设计单例模式 ?单例类如何控制其实例化如何确保只有一个实例通过一下措施解决这些问题：private构造函数,类的实例话不对外开放,由自己内部来完成这个操作,确保永远不会从类外部实例化类,避免外部随意new出来新的实例。该实例通常存储
复制链接

扫一扫