多线程---单例模式小结

synchronized和volatile负责场景的不同

synchronized:
是处理多个线程修改和修饰代码块
volatile:

1.保证变量的可见性问题

Java 线程不是直接读写主内存的变量，而是两层：
主内存：共享区域，所有线程共用
工作内存：每个线程私有缓存（CPU 缓存、寄存器）
正常普通变量流程：
线程第一次读变量：从主内存拷贝一份到自己的工作内存
后续反复读、改：只操作自己本地缓存，不再碰主内存
修改完，也不会立刻刷回主内存
👉 后果：线程 A 改了变量，只改了自己缓存；线程 B 一直读自己旧缓存，永远看不到新值。
volatile 靠 内存屏障 实现可见性：
写屏障：写之后，强制刷新缓存到主存
读屏障：读之前，强制失效本地缓存、拉取主存
没有加锁、没有阻塞，只是强制内存读写规则，所以非常轻量、性能高。

2.禁止指令重排序

JVM在优化操作的过程中,在单线程的工作模式下,会将一些操作将其内部的指令进行重新排序,但是这个在多线程的情况下,会影响多线程的工作,产生bug
经典例子就是单例模式下的懒汉模型.

wait和notify

1.wait和sleep的区别

1.wait提供两个版本,死等和带有超时的版本,sleep只有带时间的
2.sleep只能通过interrupt提前终止,而wait可以通过notify来唤醒,但也可以同时同interrupt来唤醒
3.wait阻塞是会释放锁(强制要求),sleep和锁无关,不要求搭配锁,也不会释放.

2. notify

线程是随机调度的,某个线程t1,某个线程希望后执行,另一个线程t2先执行,就可以让t1.wait等待,等到t2执行完一定逻辑之后,notify通知t1,让t1继续执行.

单例模式

饿汉模式

classSingleton{privatestaticSingletoninstance=newSingleton();publicstaticSingletongetSingleton(){returninstance;}privateSingleton(){};}

饿汉模式下,就不存在线程不安全的情况

懒汉模式

classSingletonLazy{privatestaticvolatileSingletonLazyinstance=null;privatestaticObjectlocker=newObject();publicstaticSingletonLazygetSingleton(){if(instance==null){synchronized(locker){if(instance==null){instance=newSingletonLazy();}}}returninstance;}privateSingletonLazy(){};}

这里要注意要加上volatile这一个关键字,不然在instance = new SingletonLazy()这一个操作的时候,会指令重排序,在多线程下会产生bug,双重if可以省去很大的开销,双重if分别的作用
第一个if,大大的增加了效率,后面有很多线程进来,但是先要进行第一if判断发现已经有实例对象了,就不会接着往后走了.
举个场景：
线程 A、线程 B 同时通过第一层 if，都发现 instance 是 null
线程 A 先抢到锁，进去 new 对象，释放锁
线程 B 再抢到锁，如果没有内层 if，会再次 new 一个新对象，破坏单例
有了内层 if：线程 B 抢到锁后再判断一次，发现已经有实例了，直接跳过不创建。

生产者消费者模型

publicclasstest{publicstaticvoidmain(String[]args){// 队列容量2MyBlockingQueuequeue=newMyBlockingQueue(2);// 生产者：只生产 1~10 数字newThread(()->{for(inti=1;i<=10;i++){try{queue.put(i+"");System.out.println("生产数字："+i);Thread.sleep(300);}catch(InterruptedExceptione){}}}).start();// 消费者：一直取数字newThread(()->{while(true){try{Stringnum=queue.take();System.out.println("消费数字："+num);Thread.sleep(500);}catch(InterruptedExceptione){}}}).start();}}

publicclassMyBlockingQueue{privateString[]data=null;privateinthead=0;privateinttail=0;privateintsize=0;privateObjectlocker=newObject();publicMyBlockingQueue(intcapacity){data=newString[capacity];}publicvoidput(Stringelem)throwsInterruptedException{synchronized(locker){while(size==data.length){locker.wait();}data[tail]=elem;tail++;if(tail>=data.length){tail=0;}size++;locker.notify();}}publicStringtake()throwsInterruptedException{synchronized(locker){while(size==0){locker.wait();}Stringret=data[head];head++;if(head>=data.length){head=0;}size--;locker.notify();returnret;}}}

下面是一个阻塞队列的一个实现代码重点就是要用while而不能用if
防止虚假唤醒.