尚硅谷大厂面试题第二季笔记（一）
目录
JMM（java内存模型Java Memory Model）
Volatile
Volatile是Java虚拟机提供的轻量级的同步机制：1.保证可见性。2.不保证原子性。2.禁止指令重排
保证可见性：
能保证一个线程对共享变量的修改能够及时被其他线程看到。
不保证原子性：
原子性指不可分割，完整性，也就是某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整，要么同时完成，要么同时失败。
class MyData{
volatile int number=0;
public void addT060(){
this.number=60;
}
public void add1(){number++;}
//AtomicInteger保证属性的原子性
AtomicInteger atomicInteger=new AtomicInteger();
public void addAtomic(){
atomicInteger.getAndIncrement();
}
}
public class VolatileDemo {
public static void main(String[] args) {
MyData myData=new MyData();
for(int i=0;i<20;i++){
new Thread(()->{
for (int j = 0; j < 1000; j++) {
myData.add1();
myData.addAtomic();
}
},String.valueOf(i)).start();
}
while (Thread.activeCount()>2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+"t finally number:"+myData.number);
System.out.println(Thread.currentThread().getName()+"t AtomicInteger number value:"+myData.atomicInteger);
}
//Volatile保证可见性
public static void seeOKByVolatile(){
MyData myData=new MyData();
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"t come in");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
myData.addT060();
System.out.println(Thread.currentThread().getName()+"t updated number value:"+myData.number);
},"AAA").start();
//第二个线程是main线程
while (myData.number==0){
//当main线程一直循环直到number不等于0,如果number不加Volatile修饰，则线程Main在while中一直循环
}
System.out.println(Thread.currentThread().getName()+"t over!");
}
}禁止指令重排
单线程环境里面确保程序最终执行结果和代码顺序执行结果一致，处理器在进行重排时必须考虑指令之间的数据依赖性。但在多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保持一致是无法确定的，结果无法预测
JMM（java内存模型Java Memory Model）
由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中完成，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储着主内存的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信必须通过主内存来完成，简要访问过程如下图：
单例模式在多线程下可能存在的问题
public class SingletonDemo {
private static volatile SingletonDemo instance=null;
private SingletonDemo(){
System.out.println(Thread.currentThread().getName()+":我是构造方法");
}
//DCL (double check lock双端检索机制)
public static SingletonDemo getInstance(){
if(instance==null){
synchronized (SingletonDemo.class){
if (instance==null){
instance=new SingletonDemo();
}
}
}
return instance;
}
public static void main(String[] args) {
for (int i = 0; i < 10 ; i++) {
new Thread(()->{
SingletonDemo.getInstance();
},String.valueOf(i)).start();
}
}
}
双端检索机制不一定线程安全，原因是有指令重排的存在，加入volatile可以禁止指令重排。
某一个线程执行到第一次检测，读取到instance不为null时，instance的引用对象可能还没有初始化，instance=new SingletonDemo（）；需要分为三步完成：
memory=allocate();//1.分配对象内存空间
insttance(memory);//2.初始化对象instance=memory;//3.设置instance指向刚分配地的内存地址，此时instance!=null
步骤2和步骤3不存在数据依赖关系，如果指令重排为1,3,2那么当instance！=null时，对象初始化没有完成。
指令重排只保证单线程语句执行的一致性，不关心多线程的语义一致性。所以当一条线程访问instance不为null时，由于instance实例未必已初始化，也就造成了线程安全问题
CAS
什么是CAS
Compare-And-swap，他是CPU并发原语。
他的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。
CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一- 条CPU的原子指令，不会造成所谓的数据不一致问题。
import java.util.concurrent.atomic.AtomicInteger;
/**
* Created with IntelliJ IDEA.
*
* @Author: wlh
* @Date: 2022/03/18/14:25
* @Description:
* CAS是什么？===>compareAndSet
* 比较并交换
*/
public class CASDemo {
public static void main(String[] args) {
AtomicInteger atomicInteger=new AtomicInteger(5);
System.out.println( atomicInteger.compareAndSet(5,2019)+"t current data:"+atomicInteger.get());
System.out.println( atomicInteger.compareAndSet(5 ,1024)+"t current data:"+atomicInteger.get());
}
}
CAS底层原理
1.Unsafe
Unsafe类是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，内部方法操作可以像C的指针一样直接操作内存。因为Java中CAS操作的执行依赖于Unsafe类的方法。
注意Unsafe类中所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。
为什么用CAS不用Synchronized
Synchronized加锁，一致性得到了保证，但是并发性下降。CAS既保证了一致性，又提高了并发性。
CAS缺点
getAndAddInt方法执行时，有个do while
如果CAS失败，会一直进行尝试，如果CAS长时间不成功会对CPU带来很大开销
只能保证一个共享变量的原子操作
引出ABA问题
ABA问题
CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。
比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B,然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功。
ABA问题的产生与解决
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;
/**
* Created with IntelliJ IDEA.
*
* @Author: whl
* @Date: 2022/03/19/18:08
* @Description:
*/
public class ABADemo {
static AtomicReference<Integer> atomicReference=new AtomicReference<>(100);
static AtomicStampedReference<Integer> atomicStampedReference=new AtomicStampedReference<>(100,1);
public static void main(String[] args) {
/* System.out.println("==========ABA问题的产生==========");
new Thread(()->{
atomicReference.compareAndSet(100, 101);
atomicReference.compareAndSet(101, 100);
},"t1").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
System.out.println( atomicReference.compareAndSet(100,2019)+"t"+atomicReference.get());
}catch (Exception e){}
},"t2").start();*/
System.out.println("==========ABA问题的解决==========");
new Thread(()->{
int stamp=atomicStampedReference.getStamp();
System.out.println(Thread.currentThread().getName()+"t第1次版本号"+stamp);
try {TimeUnit.SECONDS.sleep(1);
atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
System.out.println(Thread.currentThread().getName()+"t第2次版本号"+atomicStampedReference.getStamp());
atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
System.out.println(Thread.currentThread().getName()+"t第3次版本号"+atomicStampedReference.getStamp());
}catch (Exception e){}
},"t3").start();
new Thread(()->{
int stamp=atomicStampedReference.getStamp();
System.out.println(Thread.currentThread().getName()+"t第1次版本号"+stamp);
try {TimeUnit.SECONDS.sleep(3);
boolean result=atomicStampedReference.compareAndSet(100,2019,stamp,stamp+1);
System.out.println("修改是否成功："+result+"当前版本号为："+atomicStampedReference.getStamp());
System.out.println("当前值为："+atomicStampedReference.getReference());
}catch (Exception e){}
},"t4").start();
}
}
集合类不安全问题
并发修改异常
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* Created with IntelliJ IDEA.
*
* @Author: wlh
* @Date: 2022/03/20/18:01
* @Description:集合类不安全问题
*/
public class ContainerNotSafeDemo {
public static void main(String[] args) {
//故障产生
//List<String> list=new ArrayList<>();
//解法1
//List<String> list=new Vector<>();
//解法2
//List<String> list=Collections.synchronizedList(new ArrayList<>());
//解法3
List<String> list=new CopyOnWriteArrayList<>();
for (int i = 0; i < 30; i++) {
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,8));
System.out.println(list);
},String.valueOf(i)).start();
}
/*
* 故障现象
* java.util.ConcurrentModificationException
*
* 导致原因
* 并发争抢修改导致，参考花名册签名情况
* 一个人正在写，另一个人来抢夺，导致数据不一致异常，并发修改异常
*
* 解决方案
* 1.new Vector<>();
* 2.Collections.synchronizedList
* 3.new CopyOnWriteArrayList()
*
* 优化建议
*
* */
}
}
集合类不安全之Set
HashSet底层是HashMap
HashSet的put是HashMap中的Key，Value都是常量PRESENT
解决并发问题使用：CopyonWriteArraySet<E>
集合类不安全之Map
并发HashMap问题：使用ConcurrentHashMap<>()或Collections.synchronizedMap()
锁问题
公平锁和非公平锁
公平锁：指多个线程按照申请锁的顺序来获取锁，先来后到
非公平锁：指多个线程获取锁的顺序不是按照申请顺序，在高并发情况下，有可能造成优先级翻转或者饥饿现象。
Java ReentrantLock：通过构造函数指定该锁是否为公平锁，默认为非公平锁，非公平锁的优点是吞吐量比公平锁大。
对于Synchronized而言，也是一种非公平锁
可重入锁（也叫递归锁）
指同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码。在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
也就是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class test implements Runnable{
public synchronized void m1(){
System.out.println(Thread.currentThread().getName()+"t m1执行");
m2();
}
public synchronized void m2(){
System.out.println(Thread.currentThread().getName()+"t m2执行");
}
Lock lock=new ReentrantLock();
public void run(){
get();
}
public void get() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+"t invoked get()");
set();
}finally {
lock.unlock();
}
}
public void set(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+"t invoked set()");
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
test test=new test();
new Thread(()->{
test.m1();
},"t1").start();
new Thread(()->{
test.m1();
},"t2").start();
try {
TimeUnit.SECONDS.sleep(1);
}catch (Exception e){}
System.out.println();
System.out.println();
System.out.println();
System.out.println();
Thread t3=new Thread(test);
Thread t4=new Thread(test);
t3.start();
t4.start();
}
}
自旋锁
是指获取锁的线程不会立即阻塞，而是采用循环的方式尝试获取锁，好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/*
* 自旋锁：循环比较获取直到成功为止，没有类似wait的阻塞
* */
public class SpinLockDemo {
//原子引用线程
AtomicReference<Thread> atomicReference=new AtomicReference<>();
public void mylock(){
Thread thread=Thread.currentThread();
System.out.println(Thread.currentThread().getName()+"t My current coming");
while (!atomicReference.compareAndSet(null,thread)){}
}
public void myunlock(){
Thread thread=Thread.currentThread();
atomicReference.compareAndSet(thread,null);
System.out.println(Thread.currentThread().getName()+"t My current invoke");
}
public static void main(String[] args) {
SpinLockDemo spinLockDemo=new SpinLockDemo();
new Thread(()->{
spinLockDemo.mylock();
try {
TimeUnit.SECONDS.sleep(5);
}catch (Exception e){}
spinLockDemo.myunlock();
},"AAA").start();
try {
TimeUnit.SECONDS.sleep(1);
}catch (Exception e){}
new Thread(()->{
spinLockDemo.mylock();
spinLockDemo.myunlock();
},"BBB").start();
}
}
读写锁
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/*
* 多个线程同时读一个资源类没有问题，所以为了满足并发量，读取共享资源应该可以同时进行
* 但是有一个线程想去写共享资源，就不应该再有其他线程可以对该资源进行读写
* */
class MyCache//资源类
{
private volatile Map<String,Object> map=new HashMap<>();
private ReentrantReadWriteLock rwlock=new ReentrantReadWriteLock();
public void put(String key,Object value){
rwlock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"t 正在写入："+key);
try {
TimeUnit.SECONDS.sleep(1);
}
catch (Exception e){e.printStackTrace();}
map.put(key,value);
System.out.println(Thread.currentThread().getName()+"t 写入完成:"+key);
}catch (Exception e){
e.printStackTrace();
}finally {
rwlock.writeLock().unlock();
}
}
public void get(String key){
rwlock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"t 正在读取："+key);
try {
TimeUnit.SECONDS.sleep(1);
}
catch (Exception e){e.printStackTrace();}
Object object=map.get(key);
System.out.println(Thread.currentThread().getName()+"t 读取完成:"+String.valueOf(object));
}catch (Exception E){
E.printStackTrace();
}
finally {
rwlock.readLock().unlock();
}
}
}
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache=new MyCache();
for (int i = 0; i <5 ; i++) {
final int tempInt=i;
new Thread(()->{
myCache.put(tempInt+"",tempInt+"");
},String.valueOf(i)).start();
}
for (int i = 0; i <5 ; i++) {
final int tempInt=i;
new Thread(()->{
myCache.get(tempInt+"");
},String.valueOf(i)).start();
}
}
}