JUC（9）：异步回调、JMM、Volatile、DCL懒汉式！

最新推荐文章于 2023-07-01 11:54:44 发布

weixin_45801539

最新推荐文章于 2023-07-01 11:54:44 发布

阅读量99

点赞数

分类专栏： JUC并发编程文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/weixin_45801539/article/details/112302945

版权

JUC并发编程专栏收录该内容

10 篇文章 1 订阅

订阅专栏

异步回调

同步API：调用方在调用某个方法后，等待被调用方返回结果；调用方在取得被调用方的返回值后，再继续运行。调用方顺序执行，同步等待被调用方的返回值，这就是阻塞式调用。
异步API：调用方在调用某个方法后，直接返回，不需要等待被调用方返回结果；被调用方开启一个线程处理任务，调用方可以同时去处理其他工作。调用方和被调用方是异步的，这就是非阻塞式调用。

没有返回值的异步回调：

 public static void main(String[] args) throws ExecutionException, InterruptedException {
        //发起一个请求
        CompletableFuture<Void> CF =CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync->Void");
        });
        System.out.println("1111");
        CF.get();//获取阻塞执行结果
    }

有返回值的异步回调：

 public static void main(String[] args) throws ExecutionException, InterruptedException {
        //发起一个请求
        CompletableFuture<Integer> CF = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            //int i= 10/0;
            return 1024;
        });
        System.out.println(CF.whenComplete((t,u)->{
            System.out.println("t="+t);//正常的返回结果
            System.out.println("u="+u);//错误信息
        }).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233;//可以获取到错误的返向结果
        }).get());
    }

输出结果
在这里插入图片描述
把int i= 10/0的注释去掉；

JMM（java内存模型）

Java内存模型(Java Memory Model，JMM)JMM主要是为了规定了线程和内存之间的一些关系。

根据JMM的设计，系统存在一个主内存(Main Memory)，Java中所有变量都储存在主存中，对于所有线程都是共享的。

每条线程都有自己的工作内存(Working Memory)，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。

关于JMM的一些同步的约定

线程解锁前：必须把共享变量立刻刷回主存！
线程加锁前：必须读取主存中的最新值到工作内存中！
必须保证加锁和解锁是同一把锁！

JMM中的8中操作

java内存模型定义了8种操作来完成。这8种操作每一种都是原子操作。8种操作如下：

lock(锁定)：作用于主内存，它把一个变量标记为一条线程独占状态；
read(读取)：作用于主内存，它把变量值从主内存传送到线程的工作内存中，以便随后的load动作使用；
load(载入)：作用于工作内存，它把read操作的值放入工作内存中的变量副本中；
use(使用)：作用于工作内存，它把工作内存中的值传递给执行引擎，每当虚拟机遇到一个需要使用这个变量的指令时候，将会执行这个动作；
assign(赋值)：作用于工作内存，它把从执行引擎获取的值赋值给工作内存中的变量，每当虚拟机遇到一个给变量赋值的指令时候，执行该操作；
store(存储)：作用于工作内存，它把工作内存中的一个变量传送给主内存中，以备随后的write操作使用；
write(写入)：作用于主内存，它把store传送值放到主内存中的变量中。
unlock(解锁)：作用于主内存，它将一个处于锁定状态的变量释放出来，释放后的变量才能够被其他线程锁定；

Java内存模型还规定了执行上述8种基本操作时必须满足如下规则:

（1）不允许read和load、store和write操作之一单独出现（即不允许一个变量从主存读取了但是工作内存不接受，或者从工作内存发起会写了但是主存不接受的情况），以上两个操作必须按顺序执行，但没有保证必须连续执行，也就是说，read与load之间、store与write之间是可插入其他指令的。

（2）不允许一个线程丢弃它的最近的assign操作，即变量在工作内存中改变了之后必须把该变化同步回主内存。

（3）不允许一个线程无原因地（没有发生过任何assign操作）把数据从线程的工作内存同步回主内存中。

（4）一个新的变量只能从主内存中“诞生”，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量，换句话说就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。

（5）一个变量在同一个时刻只允许一条线程对其执行lock操作，但lock操作可以被同一个条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。

（6）如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作初始化变量的值。

（7）如果一个变量实现没有被lock操作锁定，则不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定的变量。

（8）对一个变量执行unlock操作之前，必须先把此变量同步回主内存（执行store和write操作）。

问题：当有多个线程时,其中一个线程改变了主内存中的值，但是其他线程不知道，就会出现错误！

如下图所示：
最开始线程1与线程2都将主存中的num= 0拿去使用，但是线程2将num=1并写入主存，此时线程1并不知道主存中num改为了1.
在这里插入图片描述

Volatile

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

保证可见性（与JMM有关）
不保证原子性：原子性不可分割
禁止指令重排

问题：如果不加lock和Synchronized，怎么保证原子性？
使用原子类来解决原子性问题。

什么是指令重排？

在计算机执行指令的顺序在经过程序编译器编译之后形成的指令序列，一般而言，这个指令序列是会输出确定的结果；以确保每一次的执行都有确定的结果。但是，一般情况下，CPU和编译器为了提升程序执行的效率，会按照一定的规则允许进行指令优化，在某些情况下，这种优化会带来一些执行的逻辑问题，主要的原因是代码逻辑之间是存在一定的先后顺序，在并发执行情况下，会发生二义性，即按照不同的执行逻辑，会得到不同的结果信息。
源代码–>编译器优化的重排–>指令并行也可能会重排->内存系统也会重排—>执行
处理器在进行指令重排的时候，考虑：数据之间的依赖性！
比如下面的例子：
在这里插入图片描述

Volatile可以避免重排

内存屏障（在单例模式中使用的最多！）：作用

保证特定的操作和执行顺序！
可以保证某些变量的内存可见性（利用这些特性Volatile实现了可见性）！
Volatile可以保证避免指令重排就是因为有内存屏障的存在！

彻底玩转单例模式

普通的单例模式
在之前的普通单例模式学习中，我们知道了在单线程下，饿汉式与懒汉式是安全是！但是在多线程下，我们的懒汉式不是线程安全的；比如：

public class Bank {
    //懒汉式
    private Bank(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static  Bank bank ;
    public static Bank getInstance(){
        if(bank == null){
            bank = new Bank();
        }
        return bank;
    }

    public static void main(String[] args) {
        //多线程并发
        for (int i = 1; i <10 ; i++) {
            new Thread(()->{
                Bank.getInstance();
            }).start();
        }
    }
}

结果：每次都不一样！
在这里插入图片描述

双重检查锁懒汉式（DCL）

将上面懒汉式部分的代码改为如下：

public class Bank {
    //懒汉式
    private Bank(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static  Bank bank ;
    public static Bank getInstance(){
        if(bank == null){//第一重锁
            synchronized (Bank.class){
                if(bank == null){//第二重锁
                    bank = new Bank();//不是原子性操作,有下面三个步骤，那么可能发生指令重排！
                     /**
                     * 1.分配内存空间
                     * 2.执行构造方法初始化对象
                     * 3.把这个对象指向这个空间
                     */
                    
                }
            }
        }
        return bank;
    }
....

再修改：

 //private static  Bank bank ;
 //改为如下
  private volatile static  Bank bank ;

这样一来就是完整的DCL懒汉式！

DCL总结：

这是双重检测加锁是保证了操作原子性，只有一个线程能创建一个实例，其他线程无法创建第二个；volatile关键字是为了防止因为指令重排导致的多线程问题，有可能线程A创建一个实例，虚拟机只执行了分配空间，对象地址引用这两步，这时线程B过来发现对象已经被创建了，但是获取到的对象是还没有被初始化的。

weixin_45801539

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC（9）：异步回调、JMM、Volatile、DCL懒汉式！

异步回调同步API：调用方在调用某个方法后，等待被调用方返回结果；调用方在取得被调用方的返回值后，再继续运行。调用方顺序执行，同步等待被调用方的返回值，这就是阻塞式调用。异步API：调用方在调用某个方法后，直接返回，不需要等待被调用方返回结果；被调用方开启一个线程处理任务，调用方可以同时去处理其他工作。调用方和被调用方是异步的，这就是非阻塞式调用。没有返回值的异步回调： public static void main(String[] args) throws ExecutionException,
复制链接

扫一扫