JUC并发编程学习（二）-CSDN博客

本文链接：https://blog.csdn.net/Reckless_hrl/article/details/121308286

本文介绍了Java中的异步回调机制，通过CompletableFuture展示了无返回值和有返回值的异步操作。同时，深入探讨了volatile关键字的作用，包括保证变量的可见性和禁止指令重排，但不保证原子性。文章还提到了Java内存模型（JMM）的相关概念，如线程的工作内存与主内存交互的规则，强调了volatile对于线程间通信的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

15、异步回调（同ajax）

拒绝阻塞，与主线程同步执行（个人理解）

package com.huang.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //runAsync 没有返回值
//        CompletableFuture<Void> future =  CompletableFuture.runAsync(()->{
//            try{
//                TimeUnit.SECONDS.sleep(2);
//            }catch (InterruptedException e){
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"runAsync=》void");
//        });
//        System.out.println(111);
//        future.get();
        //有返回值的SupplyAsync（）
        CompletableFuture<Integer> uCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName()+"uCompletableFuture=>()");
            return 1024/0;
        });
        System.out.println(uCompletableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t); //正确结果
            System.out.println("u=>" + u); //错误结果
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233;
        }).get());

    }

}

16、JMM

谈谈你对volatile的理解

Volatile是java虚拟机提供轻量级的同步机制

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

JMM：java内存模型，是一种约定不存在！

关于JMM的一些同步约定：

1、线程解锁前，必须把共享变量立刻刷回主存。

2、线程加锁前，必须读取主存中最新的值到工作内存中！

3、加锁和解锁是同一把锁

线程工作内存和主内存

八种操作：

请添加图片描述

17、Volatile

1、保证可见性：

package com.huang.VolatileDemo;

import java.util.concurrent.TimeUnit;

public class Test01 {
    private volatile static int num=0;//加了volatile分线程可以实时监测主线程中num的变化
    public static void main(String[] args) {
        new Thread(()->{
            while (num==0){//对主内存变化不知道
//                System.out.println(num);
            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }
}

2、不保证原子性：

原子性：不可分割！

如何实现原子性：加入 synochronized 和lock锁！另外还有利用原子类（利用操作系统底层代码）

package com.huang.VolatileDemo;
import java.util.concurrent.atomic.AtomicInteger;

public class AutomicTest {
    private volatile static AtomicInteger num=new AtomicInteger();
    public static void  add(){
        num.getAndIncrement();
    }
    public static void main(String[] args) {
        for (int i = 1; i <=20 ; i++) {
            new Thread(()->{
                for (int j = 1; j <=1000 ; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(num);
    }
}****

while (Thread.activeCount()>2){
Thread.yield();
}
System.out.println(num);
}
}****