1 异步回调
异步是多线程的一种特殊实现方式
📌 举例
我需要一个计算时间5秒方法的返回值
我不想等这5秒钟，我想要继续执行下面的代码，那就异步执行这个方法
当我通过get去获取这个返回值时，如果已经过了5秒，也就是方法执行完了，那我就可以直接得到返回值
如果方法还没执行完，这个时候就需要等待执行完才能拿到返回值
📌 没有返回值的 runAsync 异步回调
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"runAsync=>Void");
});
System.out.println("---------------");
completableFuture.get();//获取阻塞执行结果📌 有返回值的 runAsync 异步回调
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
return 1024;
});
completableFuture.whenComplete((t,u)->{
System.out.println("t=>"+t);//正常的返回结果
System.out.println("u=>"+u);//错误的信息
}).exceptionally((e)->{
System.out.println(e.getMessage());//可以获取到错误的结果
return 400;
});2 JMM
JMM：java内存模型，是一种约定。
线程解锁前，必须把共享变量立刻刷回主存
线程加锁前，必须读取主存中的最新值到工作内存中
加锁和解锁是同一把锁
📌 JMM模型
📌 JMM八大操作
为了支持 JMM，Java 定义了8种原子操作，用来控制主存与工作内存之间的交互：
read 读取：作用于主内存，将共享变量从主内存传送到线程的工作内存中。
load 载入：作用于工作内存，把 read 读取的值放到工作内存中的副本变量中。
store 存储：作用于工作内存，把工作内存中的变量传送到主内存中。
write 写入：作用于主内存，把从工作内存中 store 传送过来的值写到主内存的变量中。
use 使用：作用于工作内存，把工作内存的值传递给执行引擎，当虚拟机遇到一个需要使用这个变量的指令时，就会执行这个动作。
assign 赋值：作用于工作内存，把执行引擎获取到的值赋值给工作内存中的变量，当虚拟机栈遇到给变量赋值的指令时，就执行此操作。
lock锁定： 作用于主内存，把变量标记为线程独占状态。
unlock解锁： 作用于主内存，它将释放独占状态。
3 Volatile
Volatile是java虚拟机提供的轻量级的同步机制
保证可见性
不保证原子性
禁止指令重排
3.1 Volatile可见性解决ABA问题
📌 ABA问题场景
public class JMMDemo {
private static int num = 0;
public static void main(String[] args) {
new Thread(()->{
while (num==0){
}
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
num = 1;
System.out.println(num);
}
}控制台输出：
📢 程序没有停止，A线程还在循环中，因为线程A没察觉到num改变了，这就是ABA问题。
📌 解决
不加 volatile 程序就会死循环
加 volatile 可以保证可见性
往变量前缀加入volatile即可~
控制台输出：
3.2 不保证原子性
原子性：不可分割，线程A在执行任务的时候，不能被打扰，也不能被分割。要么同时成功，要么同时失败。
📌 代码举例
//volatile 不保证原子性
public class VDemo1 {
private volatile static int num = 0;
public static void add(){
num++;
}
public static void main(String[] args) {
//理论上num结果为20000
for (int i = 0; i < 20; i++) {
new Thread(()->{
for (int i1 = 0; i1 < 1000; i1++) {
add();
}
}).start();
}
while (Thread.activeCount()>2){ //main线程礼让，这样就可以最后再执行
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+num);
}
}控制台输出：
其实num++;不是原子性操作，他有以下步骤：
获得该值
+1
写回这个值
📌 使用原子类解决
这些类的底层都和直接和操作系统挂钩！直接在内存中修改值。
//volatile 不保证原子性
public class VDemo1 {
// 原子类的int
private volatile static AtomicInteger num = new AtomicInteger();
public static void add(){
//AtomicInteger +1 方法，CAS--底层
num.getAndIncrement();
}
public static void main(String[] args) {
//理论上num结果为20000
for (int i = 0; i < 20; i++) {
new Thread(()->{
for (int i1 = 0; i1 < 1000; i1++) {
add();
}
}).start();
}
while (Thread.activeCount()>2){ //main线程礼让，这样就可以最后再执行
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+num);
}
}3.3 指令重排
📌 要点
JVM自动优化编写的代码，不是自上而下的运行，会对代码重新排序后执行。
源代码-->编译器优化的重排-->指令并行可能重排-->内存系统可能重排-->执行
int x = 1; //1
int y = 1; //2
x = x + 5; //3
y = x + x; //4
源代码顺序是：1234 实际执行可能是2134、1324📌 Volatile避免指令重排
设置内存屏障，是CPU指令~
保证特定操作的执行顺序
可以保证某些变量的内存可见性
