面试易考:多线程模式下的单例模式两种具体实现(饿汉,懒汉),两个的线程安全性,阻塞队列,生产者消费者模型

简介: 面试易考:多线程模式下的单例模式两种具体实现(饿汉,懒汉),两个的线程安全性,阻塞队列,生产者消费者模型

补充:synchron(锁对象):给对象里面做了一个标记,每个对象,除了代码中写的属性外,此外还有一部分空间,存储的是标志位,这个标志位相当于是加锁,当这一位被标记加锁之后,此时其他线程也想对这个对象标识,就会进行阻塞等待。

 

面试小技巧:某某hr问,有没有女朋友,闭眼睛猛猛答没有女盆友,拒绝奇奇怪怪的送命题

    给你50w啥的你打算干什么——公司附近买房 🌝 🌝 🌝                    

 (下面的两个解决线程安全性这块还会有一部分技巧,请坚持看完,并尽量转发给你的朋友)


一、💛

初步介绍,面试的两个重点

1.单例模式:一种设计模式(设计模式:介绍了很多典型场景的处理方式,按模式写代码,不会写的很烂)

有时候希望对象,在整个线程中只实例化一次(也就是只new一次)(那么如何保证只new一次呢,靠程序猿们的嘴咩🌚🌚,男人的话不可信,所以是让编译器,去进行更严格的检查)

2.工厂模式(以后会写)

二、  💙

单例模式的细分:

1.饿汉模式(迫切):程序启动,我就立马new个床照实例。

2.懒汉模式(延时):第一次使用实例的时候,再创建,否则能不建立就不建立。

两个哪个好,也是分情况

假如一共整个大文件40G

饿汉是会一次尝试吧所有内容加载完毕,再显示出来(半小时体验卡)

懒汉是只加载一部分内容,其他部分,用户翻页用到了再去加载。

三、💜

饿汉的代码实现(一键缓存)

获取实例一定就是上面的那个实例,但是一定不能创建对象吗,其实也不是,反射可以去操作来创新(反射如同小门一样,但是不推荐用)

import java.util.Scanner;
class Singleton{
    private  static  Singleton instance=new Singleton();   //让他变成类属性
    public  static  Singleton getInstance(){               //类方法,这俩个都是类被加载
        return instance;                                     就开始使用
    }
    private  Singleton(){}               //可以让他不再new对象,要是new就报错
}
public  class  Demo {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(Singleton.getInstance());
    }
}

懒汉模式。 他需要首次调用getInstance()才会new,也就是一定是比饿汉慢的

import java.util.Scanner;
class SingletonLAZY{
    private  static  SingletonLAZY instance;
    public  static  SingletonLAZY getInstance(){           //不去调用getInstance这个方法
        if(instance==null){                              就不去去new这个对象
            instance=new SingletonLAZY();
        }
        return instance;
    }
    private  SingletonLAZY(){}                           //不让你去new对象,否则报错
}
public  class  Demo {
    public static void main(String[] args) throws InterruptedException {
        Singleton s1=Singleton.getInstance();
        Singleton s2=Singleton.getInstance();
        System.out.println(s1==s2);
    }
}

四、❤️

(情况1多线程的线程安全,多个线程调用setInsetance(务必会读(辛可肉耐子)会写)情况下,哪个代码是线程安全的

1.饿汉模式,多线程下读取instance内容,多线程读取同一个变量没有问题

2.懒汉:懒汉就会出现些问题,我那个上面的判断是否是空,然后再new个对象,但是他并不是原子性的啊(不知道啥原子性,看我前面的博客哦家人。)那么多线程情况下就会如下图所示. xx-instance.   yy-Singletion

当然某某盆友说,第二次的操作,不就是把原来的instance的引用给修改了,之前new出来的对象不是立刻就被JVM的gc回收了吗(垃圾回收机制)。最后不还是只剩一个对象了咩?

但实际上new 一个对象可能开销非常大!可能服务器启动100G内存中,都是由一个对象管理的,可能new一个花费20分钟

那么我们该如何解决呢?

首先和我们之前的处理方式一样,把if和new放到一个整体,

class Singleton{
    private  static  Singleton instance;
    public  static  Singleton getInstance() {
        synchronized (instance) {                 //把他们两个加锁
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
    private  Singleton(){}
}

这也就意味着:刚才发的图的情况,会进行阻塞,也就让这个线程没有了上述的bug。

加锁成本高,可能引起阻塞等待,无脑加锁会导致程序执行效率受到影响。

(vector,HashTable,StringBuffer,也不是很常用,他们的关键方法都用了synchronized,无论单、多线程,是否有线程安全,都会有🔒,也会影响效率)

(情况1号改进衔接2号但是像这个代码一样,每次都调用getInstance都要加锁,但是这样有必要吗?

线程不安全,主要是首次new对象才有问题,一旦对象new成功了,后续调用getInstance都是安全的。

改进:

class Singleton{
    private  static  Singleton instance;
    public  static  Singleton getInstance() {
        if(instance==null){                   //先判断是否需要创建对象
        synchronized (instance) {             //下面这两个才可能是线程安全的主要问题,加锁
            if (instance == null) {
                instance = new Singleton();
            }
        }
    }
        return instance;                     //不需要就,直接返回,没有什么线程安全问题
    }
    private  Singleton(){}
}

有人可能说同一个条件,写两遍合理吗?

之前是没有阻塞,但现在多线程,第二个条件和一个条件之间间隔非常长的时间,这个间隔,可能别的线程就把instance改变了

(情况1号衔接2号同时考虑3号情况)

两个线程

第一个线程修改完instance之后,就结束了代码块,释放了锁

第二个线程能够从中获取到锁从阻塞中恢复了

但是if(instance==null),t2的读操作一定会读到1线程修改的值吗?内存可见性问题,此处就需要给instance加上volatile(会读会写 (wao(平🐍)里太哦)

这样是更加稳妥的,只有这样才可以避免风险,毕竟编译器优化还是有点离谱的,是否会去触发优化,不好说,但是加上volatile更稳妥

并且volatile还有另外的用途,避免此处赋值操作进行指令重排序

如果单线程则不会出现指令重排序问题,但是多线程可能就会出现问题了(也是编译器优化的一种手段,保证原有执行的逻辑程序的情况下,对代码执行效率顺序调整,使执行效率提高。

instance=new SingletonLazy()分成3步

1.把对象创建出内存空间,得到内存地址

2.把空间调用构造方法,对对象进行初始化。

3.把内存地址,复制给instance重引用。

这三步可能进行重排序->单个线程先2后3,先后无所谓

但是假如t1先进行第一步,在进程第三步,第二步还没做的时候,出现了线程切换,此时还没给对象初始化就调度到其他线程了。这样t2在判读是否为空,直接返回instance,并且后续假如一直使用instance的一些属性或者方法,instance是没有被初始化啊,不可靠,不能随便用,否则什么🐮🐎情况都蹦出来了。

用volatile(保证多线程环境下的可见性,有序性)一定按123执行,此时不让他这么优化,也就不会产生重排序。

1️⃣加锁

2️⃣双层if

3️⃣volatile

面试小技巧(全是套路):考官让写这个懒汉饿汉什么的(装思考一会🤔),别一下把全优化的写上去,先装傻,写那个不完全的版本,然后他在说如何如何,再去一步一步慢慢改,让他觉得这个考题,不是你提前准备的,然后他就会觉得,小伙脑子好使,灵光


五、💚

阻塞队列(有阻塞功能的队列,下一章或者下两章是如何实现)

1.当队列满的时候,继续入队列,就会出现阻塞,阻塞到其他线程从队列中取起元素为止。

2.当队列空的时候,继续出队列,也会出现阻塞,阻塞到其他线程往队列添加元素为止

用处非常大,也很重点

通过阻塞队列可以实现生产者,消费者模型

如包饺子

生产者:整饺子皮

消费者:包饺子

放饺子的桌子就是交易场所。

六、 💓

生产者,消费者模型优势

1.解耦合(两个关系块的关系叫耦合):降低模块之间的联系

改进引入阻塞队列:

此时,A和B就通过阻塞队列很好的解耦合了~此时如果A或者B挂了,由于他们彼此之间,不会直接交互,没有啥太大影响,如果新增服务器C,此时A服务器完全不需要任何修改,只需要让他从队列中取元素就可以。

2.削峰填谷:服务器收到来自客户端/用户的请求,不是一成不变的,可能因为一些突发事件,引起请求数目暴增。(如某某明星恋情,干翻微博),正常情况下同一时刻请求的数量都是有限的。

一个分布式系统,有的机器承担压力大,有的机器承担压力小

此时A收到一个请求,B也需要立刻去处理这一个请求,如果A能承受的压力大,B能承受的压力小的话,此时,很可能B就先挂了

但假如说用上,上面的阻塞队列

削峰:当外界的请求突然暴涨,A收到的请求多了,A就会给队列中写入更多的请求数据,但是B可以依旧按照自己的节奏处理,B不至于挂了,相当于队列起到了缓冲的作用。

填谷:峰值多的时候只是暂时的~当峰值消退的时候,A收到的请求少了,B还按照原有速率去处理,不至于他特别空闲(填谷)

七、💗

JAVA提供了现成的阻塞队列

BlockingDeque:阻塞队列提供的接口,需要具体实例化类

BlockingQueue<String>queue=new ArrayBlockingQueue<>(3);//基于数组(最好提前知道他多少个元素,避免频繁扩容)


BlockingQueue<String>queue2=new PriorityBlockingQueue<>(3);//基于优先级队列(就是堆),有优先级就选它

BlockingDeque<String>queue1=new LinkedBlockingDeque<>(3);;//基于链表(不知道多少个元素使用链表,因为要修改

put tabke带阻塞功能

offer poll不带阻塞功能,

基于这个写个生产者消费者模型

import java.util.Scanner;
import java.util.concurrent.*;
public  class  Demo {
    public static void main(String[] args)  {
        BlockingDeque<Integer>queue1=new LinkedBlockingDeque<>();
        Thread t1=new Thread(()->{
            int count =0;
            while (true){
                try {
                    queue1.put(count);           //t1把生产的数字放入队列中
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("生产了元素"+count);   
                count++;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2=new Thread(()->{
            while(true) {
                Integer n = null;
                try {
                    n = queue1.take();          //t2接受他们t1线程往队列里填的数
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者" + n);
            }
        });
        t1.start();
        t2.start();
    }
}



相关文章
|
27天前
|
存储 缓存 安全
【Java面试题汇总】多线程、JUC、锁篇(2023版)
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合?ConcurrentHashMap、JUC
【Java面试题汇总】多线程、JUC、锁篇(2023版)
|
1天前
|
消息中间件 NoSQL 关系型数据库
【多线程-从零开始-捌】阻塞队列,消费者生产者模型
【多线程-从零开始-捌】阻塞队列,消费者生产者模型
10 0
|
2月前
|
Java
【多线程面试题二十五】、说说你对AQS的理解
这篇文章阐述了对Java中的AbstractQueuedSynchronizer(AQS)的理解,AQS是一个用于构建锁和其他同步组件的框架,它通过维护同步状态和FIFO等待队列,以及线程的阻塞与唤醒机制,来实现同步器的高效管理,并且可以通过实现特定的方法来自定义同步组件的行为。
【多线程面试题二十五】、说说你对AQS的理解
|
2月前
|
消息中间件 设计模式 安全
多线程魔法:揭秘一个JVM中如何同时运行多个消费者
【8月更文挑战第22天】在Java虚拟机(JVM)中探索多消费者模式,此模式解耦生产与消费过程,提升系统性能。通过`ExecutorService`和`BlockingQueue`构建含2个生产者及4个消费者的系统,实现实时消息处理。多消费者模式虽增强处理能力,但也引入线程安全与资源竞争等挑战,需谨慎设计以确保高效稳定运行。
74 2
|
2月前
|
消息中间件 缓存 算法
Java多线程面试题总结(上)
进程和线程是操作系统管理程序执行的基本单位,二者有明显区别: 1. **定义与基本单位**:进程是资源分配的基本单位,拥有独立的内存空间;线程是调度和执行的基本单位,共享所属进程的资源。 2. **独立性与资源共享**:进程间相互独立,通信需显式机制;线程共享进程资源,通信更直接快捷。 3. **管理与调度**:进程管理复杂,线程管理更灵活。 4. **并发与并行**:进程并发执行,提高资源利用率;线程不仅并发还能并行执行,提升执行效率。 5. **健壮性**:进程更健壮,一个进程崩溃不影响其他进程;线程崩溃可能导致整个进程崩溃。
38 2
|
2月前
|
存储 缓存 安全
Java多线程面试题总结(中)
Java内存模型(JMM)定义了程序中所有变量的访问规则与范围,确保多线程环境下的数据一致性。JMM包含主内存与工作内存的概念,通过8种操作管理两者间的交互,确保原子性、可见性和有序性。`synchronized`和`volatile`关键字提供同步机制,前者确保互斥访问,后者保证变量更新的可见性。多线程操作涉及不同状态,如新建(NEW)、可运行(RUNNABLE)等,并可通过中断、等待和通知等机制协调线程活动。`volatile`虽不确保线程安全,但能确保变量更新对所有线程可见。
18 0
|
2月前
|
Java 程序员 容器
【多线程面试题二十四】、 说说你对JUC的了解
这篇文章介绍了Java并发包java.util.concurrent(简称JUC),它是JSR 166规范的实现,提供了并发编程所需的基础组件,包括原子更新类、锁与条件变量、线程池、阻塞队列、并发容器和同步器等多种工具。
|
2月前
|
缓存 Java
【多线程面试题二十三】、 说说你对读写锁的了解volatile关键字有什么用?
这篇文章讨论了Java中的`volatile`关键字,解释了它如何保证变量的可见性和禁止指令重排,以及它不能保证复合操作的原子性。
|
2月前
|
Java
【多线程面试题二十二】、 说说你对读写锁的了解
这篇文章讨论了读写锁(ReadWriteLock)的概念和应用场景,强调了读写锁适用于读操作远多于写操作的情况,并介绍了Java中`ReentrantReadWriteLock`实现的读写锁特性,包括公平性选择、可重入和可降级。
|
2月前
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输,之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。