并发编程（一）可见性

已于 2022-11-19 13:20:00 修改
阅读量354 收藏
点赞数 1
分类专栏： Java多线程 文章标签： java
于 2022-11-19 13:02:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyuanduan/article/details/127877807
版权

【并发编程三大特性】：

可见性
有序性
原子性（ 较复杂 ）

【线程的可见性】：

【一个例子认识线程的可见性】：

import Utils.SleepHelper;
import java.io.IOException;

public class T01_HelloVolatile {
    private static  boolean running = true;  //位于主内存当中。

    private static void m() {
        System.out.println("m start");
        while (running) {
        	//程序最终将陷在这里，一直进入死循环。
        }
        System.out.println("m end!");
    }

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

        new Thread(T01_HelloVolatile::m, "t1").start();

        SleepHelper.sleepSeconds(1);

        running = false;
    }
}

【最终输出】：
在这里插入图片描述
//发现程序停下了，一直在运行并没有结束。

【 并不会每次都去读去堆内存 】：

running位于主存当中，T1线程只去读取一次；
在上面的代码中，running是存在于堆内存的t对象中

  • 当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去
  • 读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行
  • 使用volatile，将会强制所有线程都去堆内存中读取running的值
  • volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized

【引入Volatile关键字】：

/**
 * volatile 关键字，使一个变量在多个线程间可见
 * A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道
 * 使用volatile关键字，会让所有线程都会读到变量的修改值
 * <p>
 * 在下面的代码中，running是存在于堆内存的t对象中
 * 当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去
 * 读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行
 * <p>
 * 使用volatile，将会强制所有线程都去堆内存中读取running的值
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
 */
package T02_Thread_Volatile;

import Utils.SleepHelper;

import java.io.IOException;

public class T01_HelloVolatile2 {
    private static volatile boolean running = true;  //位于主内存当中。

    private static void m() {
        System.out.println("m start");
        while (running) {
            //System.out.println("hello");
        }
        System.out.println("m end!");
    }

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

        new Thread(T01_HelloVolatile2::m, "t1").start();

        SleepHelper.sleepSeconds(1);

        running = false;

    }
}

【最终输出】：
在这里插入图片描述

【理解】：

volatile修饰的那块内存，对于它的任何修改，其他的线程立马可见。——保持可见性。

【线程间好像又可见了】：

import Utils.SleepHelper;
import java.io.IOException;

public class T01_HelloVolatile3 {
    private static  boolean running = true;  //位于主内存当中。

    private static void m() {
        System.out.println("m start");
        while (running) {
            System.out.println("hello");     //这里会触发可见性机制！！！！！！！！！！！
        }
        System.out.println("m end!");
    }

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

        new Thread(T01_HelloVolatile3::m, "t1").start();

        SleepHelper.sleepSeconds(1);

        running = false;
    }
}

【最终输出】：
在这里插入图片描述
//在输出若干个hello之后 ， 线程结束了。

【触发了可见性机制】：

在这里插入图片描述
//synchronized也是可以保持可见性的。
【简单理解】：
在某些语句执行的情况下，它是可以触发本地的缓存和我们主内存之间的数据进行一个刷新和同步。

【volatile修饰引用类型】：

volatile 引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段的可见性。
在这里插入图片描述
//内存中有一个A对象 ， 小a指向它 ， 这个a是被volatile修饰的 ， 两个线程本地的缓存里也都有一个 r , 一个线程修改自己内部的缓存r , 其他线程并不会可见 。
但是，如果小a指向的内容被修改了，其他线程就可见了.
在这里插入图片描述

[测试程序]:

public class T02_VolatileReference {

    private static class A {
        boolean running = true;   //要加volatile的话加在这里 ～

        void m() {
            System.out.println("m start");
            while (running) {
            }
            System.out.println("m end!");
        }
    }

    private volatile static A a = new A();

    public static void main(String[] args) {
        new Thread(a::m, "t1").start();
        SleepHelper.sleepSeconds(1);
        a.running = false;
    }
}

【输出】：
运行程序，发现一直在循环。
在这里插入图片描述

【改进程序】：

public class T02_VolatileReference2 {

    private static class A {
       volatile boolean running = true;
        void m() {
            System.out.println("m start");
            while (running) {
            }
            System.out.println("m end!");
        }
    }

    private volatile static A a = new A();

    public static void main(String[] args) {
        new Thread(a::m, "t1").start();
        SleepHelper.sleepSeconds(1);
        a.running = false;
    }
}

【最终输出】：
在这里插入图片描述

【三级缓存】：

Registers -> L1 -> L2 -> L3 -> 内存。
寄存器需要一个数据首先会去L1里找，然后依次去L2、L3、内存中找。回去的时候先往L3中存一份，再往L2中存2一份，再往L1中存一份，最后存到寄存器里。我们说的可见性并不是ThreadLocal , 而是各个CPU中L123的数据的可见性。
在这里插入图片描述
在这里插入图片描述

【缓存行的基本概念】：

【读数据时的效率】：

并非每次需要变量都是从内存中读取数据都是L3、2、1这种，而是一整块儿一整块儿地从内存中读出来。
【程序的局部性原理】：
按块读取；
程序局部性原理 ， 可以提高效率；
充分发挥总线CPU针脚等一次性读取更多数据的能力。
【空间局部性原理】：
当我用到某一个值的时候，我很快就会用到和它相邻的值。用到这个值的时候，我一次性把它周边的值都给读取到缓存里，并非只读一个。
在这里插入图片描述

【时间局部性原理】：
当我用到一个指令的时候 ， 很快我会用到和它相邻的指令，也是一次性地将很多指令相关的数据全给读取到内存里面；

【这一块儿数据到底有多大呢？】：

专业名词——CacheLine ， 一行大小64bytes 。
在这里插入图片描述

【 通过程序认识缓存一致性 】：

public class T01_CacheLinePadding {
    public static long COUNT = 10_0000_0000L;

    private static class T {
        public long x = 0L; //8 bytes  ——————8个Long类型就能够把缓存行给填满。
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        CountDownLatch latch = new CountDownLatch(2);

        Thread t1 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[0].x = i;
            }

            latch.countDown();
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[1].x = i;
            }

            latch.countDown();
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        latch.await();
        System.out.println((System.nanoTime() - start) / 100_0000);
    }
}

【最终输出】：
在这里插入图片描述
//运行了很多次——几乎都在600左右～～～。

【修改程序】：

在上述程序的基础上只修改一处：

    private static class T {
        private long p1, p2, p3, p4, p5, p6, p7;
        public long x = 0L; //8bytes
        private long p9, p10, p11, p12, p13, p14, p15;
    }

【最终发现】：
程序运行变快了——到了300多秒！！！！！！

//跟volatile没有关系 ， 你加不加volatile都能够体现出效率的区别来。
在这里插入图片描述
//这是由于缓存一致性协议所导致的。
在这里插入图片描述
//多线程修改的内容位于同一缓存行的情况时会互相干扰。CPU1中的缓存行修改了，会去通知CPU2 ，同样CPU2中缓存行修改了会去通知CPU1。
在这里插入图片描述
前面加7个变量也就是56字节，56+8=64 ， 所以任意两个变量绝对不会位于同一个缓存行当中。————互相之间不用做通知了，互相之间也不用同步了。

【 Disruptor闪电框架源码 】：

在这里插入图片描述
//最后面堆了7个Long就是为了利用缓存行机制。

【 认识Contended 】：

认识一个注解——Contended 。
被这个注解所标注的数据不会和其他数据位于同一缓存行。
【先不加注解】：

 import sun.misc.Contended;
//注意：运行这个小程序的时候，需要加参数：-XX:-RestrictContended
import java.util.concurrent.CountDownLatch;

public class T05_Contended {
    public static long COUNT = 10_0000_0000L;

    //@Contended  //只有1.8起作用 , 保证x位于单独一行中
    private static class T {
        public long x = 0L;
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        CountDownLatch latch = new CountDownLatch(2);

        Thread t1 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[0].x = i;
            }

            latch.countDown();
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[1].x = i;
            }

            latch.countDown();
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        latch.await();
        System.out.println((System.nanoTime() - start) / 100_0000);
    }
}

【再加上注解比较两者的速度】：


import sun.misc.Contended;
//注意：运行这个小程序的时候，需要加参数：-XX:-RestrictContended
import java.util.concurrent.CountDownLatch;

public class T05_Contended2 {
    public static long COUNT = 10_0000_0000L;

    //@Contended  //只有1.8起作用 , 保证x位于单独一行中
    private static class T {
        @Contended
        public long x = 0L;
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        CountDownLatch latch = new CountDownLatch(2);

        Thread t1 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[0].x = i;
            }

            latch.countDown();
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[1].x = i;
            }

            latch.countDown();
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        latch.await();
        System.out.println((System.nanoTime() - start) / 100_0000);
    }
}

//可以发现效率会大幅度地提升。
需要加上如下参数：
在这里插入图片描述
//默认情况下Contended的注解是被限制住的。你必须把这个参数打开，否则加了也不会起作用。

【 硬件层面的缓存一致性 】：

缓存一致性不要和MESI概念混淆。
在这里插入图片描述
//不同类型的CPU所采用的缓存一致性协议是不一样的。
MESI只是缓存一致性协议中的一种，这个协议是Intel公司设计的。MESI指的是缓存行的四种状态。
Modified——-被修改了；
Exclusive——独享；
Shared———共享；
Invalid———-失效；

Volatile底层并不是由MESI协议实现的！！！

【为什么缓存行一行64字节？】：

//工业实践当中得出的最佳实践。
缓存行越大 ， 局部性空间效率越高 ， 但读取时间慢。（缓存行大了的话，读取的时间就慢了。）
缓存行越小， 局部性空间效率越低 ， 但读取时间快。
取一个折中值，目前多用：————64字节。

【总结】：

  • volatile保障线程可见性
  • 缓存行
  • 缓存一致性协议

【volatile的底层实现】：
volatile除了保障线程可见性之外 ， 它还可以禁止重排序。了解完有序性之后才能真正理解它的底层实现原理。

无量寂空
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
并发三大特性——可见性
Jack 架构师之路
10-28 2万+
引言 熟悉并发的童鞋们都知道，并发编程有三大特性，分别是可见性、有序性、原子性，今天我们从一个demo中分析可见性，以及我们如何保障可见性。 JMM模型 在我们分析可见性之前，我们需要了解一个概念，就是JMM模型，也就是我们常说的javamemorymodel . java虚拟机规范中定义了Java内存模型，用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现程序在各个平台上达到一致的并发效果，JMM规范了java虚拟机与计算机内存是如何协同工作的。规定了一个线程如何和何时可以看到由其他线程修改过..
Java并发编程-volatile可见性详解
08-26
Java并发编程-volatile可见性详解 Java并发编程中，volatile关键字扮演着非常重要的角色，它提供了两个主要功能：可见性和防止指令重排序。在本文中，我们将详细介绍volatile的可见性机制。 可见性是指多个线程...
并发编程三大特性：2、可见性（什么是可见性、解决可见性的方式）
Arden的博客
05-17 466
可见性问题是基于CPU位置出现的，CPU处理速度非常快，相对CPU来说，去主内存获取数据这个事情太慢了，CPU就提供了L1，L2，L3的三级缓存，每次去主内存拿完数据后，就会存储到CPU的三级缓存，每次去三级缓存拿数据，效率肯定会提升。这就带来了问题，现在CPU都是多核，每个线程的工作内存（CPU三级缓存）都是独立的，会告知每个线程中做修改时，只改自己的工作内存，没有及时的同步到主内存，导致数据不一致问题。可见性问题的代码逻辑// ....System.out.println("t1线程结束");
并发编程的特性——可见性
qq_41683000的博客
03-18 550
并发编程的特性——可见性
并发编程-可见性、原子性与有序性
鱼粉大王
04-17 567
内存屏障提供了一套解决CPU缓存优化而导致的顺序性和可见性问题的方案，但是由于不同的硬件系统提供给的“内存屏障”指令都不一样，所以作为软件开发人员来说需要熟悉每个内存屏障的指令实在没必要，所以我们的JAVA语言把不同的内存屏障指令统一进行了封装，让我们的程序员不需要关心到系统的底层，只需要关心他们的自己的程序逻辑开发和如何使用这套规范即可，而封装这套解决方案的模型就是我们常说的Java内存模型JMM(Java Memory Model)重新排序的目的是为了提升CPU的执行效率，合理的利用CPU的等待时间。
并发编程的三大特性之可见性
舒一笑的博客
05-27 91
Lock锁的实现是基于volatile实现，在内部进行加锁和释放锁，对一个由volatile修饰的state变量做加减操作。针对volatile属性被读出，JMM会将当前线程CPU中的缓存置为无效，需要从主内存中重新获取值。针对volatile属性被写入，JMM会将当前线程的CPU缓存的数据及时刷新到主内存中。添加在这里是会失败的得不到预期的效果。使用synchronized锁。使用volatile关键字。volatile的内存语义。
并发编程之可见性
weixin_36401695的博客
11-16 701
线程安全性之可见性有序性 看下面的代码，t1线程中用到了stop属性，在main线程中修改了stop属性的值来使得t1线程结束，但是t1线程并没有按照期望的结果执行。 public class VolatileDemo { public static boolean stop=false; public static void main(String[] args) throws InterruptedException { Thread t1=new Thread(()->{
Java并发编程实战 02Java如何解决可见性和有序性问题
12-21
Java并发编程中的可见性和有序性问题是多线程环境下常见的挑战，这两个问题直接影响程序的正确性和性能。Java内存模型（Java Memory Model，JMM）就是为了应对这些问题而设计的规范，它规定了Java虚拟机（JVM）如何...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一部分，涉及到多线程、同步机制、线程池以及并发工具类等多个核心知识点。以下是对这些主题的详细说明： 1. **线程安全与锁 Synchronized 底层实现原理**： 线程安全是指在多...
2023 java并发编程手册
02-21
volatile 变量是 Java 语言中的一种特殊变量，可以确保变量的可见性和原子性。volatile 变量可以用于实现线程安全的 comunicatoin。 5. 锁机制 锁机制是 Java 语言中的一种线程安全机制，用于保护共享资源的访问。...
高并发编程,高并发编程,高并发编程
01-10
* volatile关键字可以确保变量的可见性和原子性。 * synchronized关键字可以确保方法或代码块的线程安全性。 * Lock接口可以提供更加灵活的线程安全机制。 高并发编程需要考虑多线程、线程安全、线程池、异步编程等...
并发编程之可见性、并发、并行
未知的希望，是我不灭的信仰
10-31 285
并发编程之并发、并行、可见性
并发编程三个特性——可见性(visibility)
小小葩的博客
07-10 282
并发编程之线程的可见性相关
Java并发编程之可见性分析 volatile
m0_73311735的博客
11-18 1271
例如，线程A和线程B，它们都是直接修改主内存中的共享变量，无论是线程A修改了共享变量，还是线程B修改了共享变量，则另一个线程从主内存中读取出来的变量值，一定是修改过的值，这就是线程的可见性。这些线程都是运行在同一个CPU上，操作的是同一个CPU的缓存，只要其中一个线程修改了共享变量的值，那另外的线程就一定能够访问到修改后的变量值。例如，上面的图中，由于CPU是多核的，线程A操作的是CPU-01上的缓存，线程B操作的是CPU-02上的缓存，此时，线程A对变量V的修改对线程B是不可见的，反之亦然。
并发编程核心问题 - 可见性,有序性, 原子性
xx12321q的博客
05-27 266
目录 可见性问题 有序性问题 volatile 关键字 原子性问题 i ++是安全的吗? 如何保证原子性? CAS(Compare-And-Swap) ABA问题 可见性问题 在如今的多核CPU中 , 由于CPU与内存存在速度差异, 所以每个核都有自己的缓存, 缓存是私有的, 这就导致CPU缓存与内存中的数据可能会出现不一致的情况 CPU在自己的缓冲区拿到数据进行写操作之后, 并不会立刻将这个数据更新回内存中, 如果此时来了另一个线程, 它此时应该读入的是上...
多线程学习五并发编程的可见性
lsd&xql的博客
10-28 177
并发编程的可见性 可见性是否一定要加volatile才能让线程可见？volatile修饰的引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段的可见性理解线程中的缓存缓存行基本概念理解 可见性 看如下代码： public class HelloVolatile { private static volatile boolean running = true; //private static /*volatile*/ boolean running = true; priv
并发编程中的可见性问题
weixin_42126028的博客
09-04 647
并发编程的三个问题 可见性（Visibility）：是指一个线程对共享变量进行修改，另一个先立即得到修改后的新值。 原子性（Atomicity）：在一次或多次操作中，要么所有的操作都执行并且不会受其他因素干扰而中 断，要么所有的操作都不执行。 有序性（Ordering）：是指程序中代码的执行顺序，Java在编译时和运行时会对代码进行优化，会导致 程序终的执行顺序不一定就是我们编写代码时的顺序。 从可见性说起，看下面的代码 public class VolatileTest { private s
并发编程基础知识，java内存模型及多线程、volatile
最新发布
04-29
"Java并发编程基础知识，包括Java内存模型（JMM）、多线程的核心概念以及volatile关键字的使用。" Java内存模型（JMM）是为了保证多线程环境下的正确协同工作而设立的一套规则。它关注的是原子性、可见性和有序性这...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值