补充: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(); } }