JAVA多线程-(五)并发编程三大特性之有序性volatile

本文探讨了Java并发编程中的有序性问题,通过一个示例展示了由于指令重排序导致的程序乱序执行。内存屏障作为解决手段,用于阻止乱序执行。volatile关键字在确保内存可见性的同时,也提供了某种程度的有序性保障。文章还介绍了Java内存模型的happens-before原则,以及内存屏障的四种类型。最后,讨论了volatile的实现细节及其在保证有序性方面的作用。
摘要由CSDN通过智能技术生成

并发编程三大特性

有序性
证明乱序

package com.juc.c_001_03_Ordering;

/**
 * 本程序跟可见性无关,曾经有同学用单核也发现了这一点
 */

import java.util.concurrent.CountDownLatch;

public class T01_Disorder {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {

        for (long i = 0; i < Long.MAX_VALUE; i++) {
            x = 0;
            y = 0;
            a = 0;
            b = 0;
            CountDownLatch latch = new CountDownLatch(2);

            Thread one = new Thread(new Runnable() {
                public void run() {
                    a = 1;
                    x = b;

                    latch.countDown();
                }

            });

            Thread other = new Thread(new Runnable() {
                public void run() {
                    b = 1;
                    y = a;

                    latch.countDown();
                }
            });
            one.start();
            other.start();
            latch.await();
            String result = "第" + i + "次 (" + x + "," + y + ")";
            if (x == 0 && y == 0) {
                System.err.println(result);
                break;
            }
        }
    }

}

运行上面程序当x和y等于0的时候,证明程序执行乱序了。
在这里插入图片描述程序为何乱序?
简单说,为了提高效率。因为读取内存和CPU计算速度不一致, 前后两条指令没有依赖可能会乱序。
在这里插入图片描述
线程的as-if-serial
▪ as – if – serial
▪ 不影响单线程的最终一致性
▪ 单个线程,两条语句,未必是按顺序执行
▪ 单线程的重排序,必须保证最终一致性
▪ as-if-serial:看上去像是序列化(单线程)
JVM内存屏障
使用内存屏障阻止乱序执行
内存屏障是特殊指令:看到这种指令,前面的必须执行完,后面的才能执行
intel : lfence sfence mfence(CPU特有指令)
▪ LoadLoad屏障:对于这样的语句Load1; LoadLoad; Load2,在Load2及后续读取操作要读取的数据被访问前,保证Load1要读取的数据被读取完毕。
▪ StoreStore屏障:对于这样的语句Store1; StoreStore; Store2,在Store2及后续写入操作执行前,保证Store1的写入操作对其它处理器可见。
▪ LoadStore屏障:对于这样的语句Load1; LoadStore; Store2,在Store2及后续写入操作被刷出前,保证Load1要读取的数据被读取完毕。
▪ StoreLoad屏障:对于这样的语句Store1; StoreLoad; Load2,在Load2及后续所有读取操作执行前,保证Store1的写入对所有处理器可见。
如何阻止乱序?
▪ volatile(JVM级别)
▪ 内存屏障
new 对象指令

Object obj = new Object();

0 new #2 <java/lang/Object>
3 dup
4 invokespecial #1 <java/lang/Object.<init>>
7 astore_1
8 return

▪ 当new一个对象的时候,先在堆内存申请一块内存,地址压栈,这个时候对象是默认值;
▪ dup复制地址 ,压栈,现在有两个地址,内存对象是默认值;
▪ invokespecial调用init执行默认构造方法,对象赋初始值,出栈用掉一个地址;
▪ astore1弹栈到方法变量表赋值给o;

程序在运行的时候会发生指令重排序,有可能拿到对象引用的时候还没有执行构造方法赋初始值,这个时候对象内部的数据还是默认值。

this对象逸出

package com.juc.c_001_03_Ordering;

public class T03_ThisEscape {

    private int num = 8;


    public T03_ThisEscape() {
        new Thread(() -> System.out.println(this.num)
        ).start();
    }

    public static void main(String[] args) throws Exception {
        new T03_ThisEscape();
        System.in.read();
    }
}
//构造方法不要启动线程

成员变量 new T03_ThisEscape
1分配空间申请内存 赋默认值
2然后调用构造方法 赋初始值
3内存地址赋予变量
如果调用顺序是1,3,2 这就是指令重排,把分配空间指向变量,但是还没有调用调用构造方法,如果这个时候调用这个方法,num 是不为8的,但是对象.成员变量是没有初始化的。

volatile 是如何保证有序性的
Java 内存模型具备一些先天的“有序性”,即不需要通过任何手段就能够得到保证的有序性,这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从 happens-before 原则推导出来,那么它们就不能保证它们的有序性,虚拟机可以随意地对它们进行重排序。

如下是 happens-before 的8条原则,摘自 《深入理解Java虚拟机》。
▪ 程序次序规则:一个线程内,按照代码顺序,书写在前面的操作先行发生于书写在后面的操作;
▪ 锁定规则:一个 unLock 操作先行发生于后面对同一个锁的 lock 操作;
▪ volatile 变量规则:对一个变量的写操作先行发生于后面对这个变量的读操作;
▪ 传递规则:如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生于操作C;
▪ 线程启动规则:Thread对象的start()方法先行发生于此线程的每个一个动作;
▪ 线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生;
▪ 线程终结规则:线程中所有的操作都先行发生于线程的终止检测,我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行;
▪ 对象终结规则:一个对象的初始化完成先行发生于他的 finalize() 方法的开始;
JVM中的内存屏障
所有实现JVM规范的虚拟机,必须实现四个屏障
LoadLoadBarrier LoadStore SL SS

Volicate实现细节

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值