并发编程三个特性——可见性(visibility)

最新推荐文章于 2024-04-17 16:10:36 发布
最新推荐文章于 2024-04-17 16:10:36 发布
阅读量282 收藏
点赞数
分类专栏： 多线程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36184384/article/details/125691195
版权

1、线程间的内存同步模型
在这里插入图片描述
2、volatile修饰变量，保证变量在线程之间的可见性，以下示例是使用volatile的情况

package com.yang.Threads;


import java.util.concurrent.TimeUnit;

/**
 * @Author: Gy
 * @Description: 测试线程之间的可见性
 * @Date 
 * @Modified By:
 */
public class TestVolatile {

    private static volatile boolean running = false;

    public static void main(String[] args) throws InterruptedException {
        childThread1();
        TimeUnit.SECONDS.sleep(2);
        childThread2();
    }

    public static void childThread1(){

        Thread t1 = new Thread(() -> {

            System.out.println("t1 start");

            while (!running) {
//                System.out.println("t1 go on");
            }
            System.out.println("t1 has been stoped");
        });
        t1.start();
    }

    public static void childThread2(){

        Thread t2 = new Thread(() -> {
            running = true;
        });
        t2.start();
    }

}

实践后可得出结论，线程t2修改了running = true后，线程t1能够正常停止，说明t1工作内存中的running变量被同步更新了；相反如果不适用volatile修饰running变量，t2修改变量值后，仅仅刷新了主内存中的值，t1中的变量值不能同步更新，所以t1一直运行，不能停止。

3、在不使用volatile的情况下，使用线程的某些阻塞方法（如sleep())和唤醒方法以及system.out.println中的synchronized关键字都会触发变量在线程之间的可见性，也就是内存同步的操作

package com.yang.Threads;

import java.util.concurrent.TimeUnit;

/**
 * @Author: Gy
 * @Description: 测试线程之间的可见性
 * @Date 
 * @Modified By:
 */
public class TestVolatile {

    private static boolean running = false;

    public static void main(String[] args) throws InterruptedException {
        childThread1();
        TimeUnit.SECONDS.sleep(2);
        childThread2();
    }

    public static void childThread1(){

        Thread t1 = new Thread(() -> {

            System.out.println("t1 start");

            while (!running) {
                System.out.println("t1 go on");
            }
            System.out.println("t1 has been stoped");
        });
        t1.start();
    }

    public static void childThread2(){

        Thread t2 = new Thread(() -> {
            running = true;
        });
        t2.start();
    }

}

此示例中，因为t1的while循环内部有System.out.println(“t1 go on”)，而这句底层包含synchronized关键字，所以触发了线程之间的内存同步，t1的工作内存中也是可以获取最新值的，所以线程t1可以正常停止。那么我们是不是就可以利用这个特性来实现线程之间的可见性呢？答案是否定的，试想一下，sout相当于是加锁操作，势必会导致程序的执行效率，所以该用volatile就用volatile。

4、volatile修改引用类型，只能保证引用本身的可见性，不能保证该引用内部字段的可见性，示例如下

package com.yang.Threads;

import java.util.concurrent.TimeUnit;

/**
 * @Author: Gy
 * @Description: volatile修饰引用类型（Inner的引用），该引用中的字段改变不能触发可见性（除非修改该引用的地址值，如新建一个引用赋值给该引用
 * @Date 
 * @Modified By:
 */
public class TestVolatile3 {

    private static class Inner{
        boolean running = true;
        void inner_m(){
            System.out.println("inner_m start");
            while (running){

            }
            System.out.println("inner_m stop");
        }
    }
    private volatile static Inner inner = new Inner();
    public static void main(String[] args) throws InterruptedException {
        new Thread(inner::inner_m,"t1").start();
        TimeUnit.SECONDS.sleep(2);
        inner.running = false;
    }
}

上边示例，子线程t1不能停止，如果要引用的内部字段可见，可用volatile直接修饰引用类型内部字段，示例如下

package com.yang.Threads;

import java.util.concurrent.TimeUnit;

/**
 * @Author: Gy
 * @Description: volatile直接修饰引用类型的内部字段，实现内部字段在线程之间的可见性（即内存同步）
 * @Date
 * @Modified By:
 */
public class TestVolatile3 {

    private static class Inner{
        volatile boolean running = true;
        void inner_m(){
            System.out.println("inner_m start");
            while (running){

            }
            System.out.println("inner_m stop");
        }
    }
    private static Inner inner = new Inner();
    public static void main(String[] args) throws InterruptedException {
        new Thread(inner::inner_m,"t1").start();
        TimeUnit.SECONDS.sleep(2);
        inner.running = false;
    }
}

此时，线程t1可以正常停止。

5、三级缓存及线程之间变量的可见性
在这里插入图片描述
在这里插入图片描述
接下来，借用一个实例，引入缓存行（cache line）的概念，假如现在有个小程序，我们需要从主内存中读取变量x(int类型4个字节长度),那么这个变量是依次被缓存进L3->L2->L1中的吗？那么一万个变量呢？也是一个一个的被逐级缓存进去的吗？答案是否定的，事实上，变量的读取是按块读取的，这个块也就是一个缓存行（大小是64个字节长度），所以每次都是读取一个缓存行，并不是一个变量一个变量的存进缓存，相当于每次都是批量读取的，有利于提高效率。当线程读取x变量的时候，也会把x附近的y变量一同放进缓存，见下图
在这里插入图片描述
下面通过两个小程序认识缓存行
程序一

package com.yang.Threads;

import java.util.concurrent.CountDownLatch;

/**
 * @Author: Gy
 * @Description:
 * @Date 
 * @Modified By:
 */
public class TestCacheline {

    private static long COUNT = 1000000000L;

    private static class T{
//        private long a,b,c,d,e,f,g;
        private long h = 0L;
//        private long i,j,k,l,m,n,o;
    }

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

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

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Thread t1 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                array[0].h = i;
            }
            countDownLatch.countDown();
        });

        final Thread t2 = new Thread(()->{
            for (long i = 0; i < COUNT ; i++) {
                array[1].h = i;
            }
            countDownLatch.countDown();
        });
        final long startTime = System.nanoTime();
        t1.start();
        t2.start();
        countDownLatch.await();
        System.out.println((System.nanoTime()-startTime)/1000000);
    }
}

该程序的执行时间为335毫秒。
程序二，释放掉程序一中注释的变量

package com.yang.Threads;

import java.util.concurrent.CountDownLatch;

/**
 * @Author: Gy
 * @Description:
 * @Date 
 * @Modified By:
 */
public class TestCacheline {

    private static long COUNT = 1000000000L;

    private static class T{
        private long a,b,c,d,e,f,g;
        private long h = 0L;
        private long i,j,k,l,m,n,o;
    }

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

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

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Thread t1 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                array[0].h = i;
            }
            countDownLatch.countDown();
        });

        final Thread t2 = new Thread(()->{
            for (long i = 0; i < COUNT ; i++) {
                array[1].h = i;
            }
            countDownLatch.countDown();
        });
        final long startTime = System.nanoTime();
        t1.start();
        t2.start();
        countDownLatch.await();
        System.out.println((System.nanoTime()-startTime)/1000000);
    }
}

执行时间为291毫秒。
可以明显看出，程序二的执行效率更高，节省的时间是同一个缓存行数据同步的时间。先分析程序一，array数组中包含T1和T2两个对象，每个对象各包含一个长度为8个字节的变量，两个对象的长度分别比8个字节稍微大一点，总体小于64个字节，所以这俩对象大概率会出现在一个缓存行之中，当线程t1修改T1时，t1的L1缓存中包含T1和T2(前面说了T1和T2位于同一个缓存行)，当t2线程修改T2时，t2的L1缓存中也包含T1和T2,也就是说，两个线程中要修改的变量存在同一个缓存行中，而这个缓存行有时两个线程L1缓存中共有的，所以根据缓存行的一致性协议（cpu硬件层面约定的缓存一致性），当t1线程修改L1缓存中T1的h属性时，会同步t2的L1缓存中T1做出修改从而保持一致。整个过程的图解见下图在这里插入图片描述
再分析程序二节省了时间的原因，程序二中在变量h前后分别填充了7个long类型的变量，所以T1和T2不可能在同一个缓存行中，所以t1和t2线程修改各自的变量的时候不涉及缓存行的同步过程，所以节省了时间，看下图在这里插入图片描述

自此结束，以上内容是我学习后输出的成果，如果内容有错误，希望指教更正

大番薯_y
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并发三大特性——可见性
Jack 架构师之路
10-28 2万+
引言 熟悉并发的童鞋们都知道，并发编程有三大特性，分别是可见性、有序性、原子性，今天我们从一个demo中分析可见性，以及我们如何保障可见性。 JMM模型 在我们分析可见性之前，我们需要了解一个概念，就是JMM模型，也就是我们常说的javamemorymodel . java虚拟机规范中定义了Java内存模型，用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现程序在各个平台上达到一致的并发效果，JMM规范了java虚拟机与计算机内存是如何协同工作的。规定了一个线程如何和何时可以看到由其他线程修改过..
并发编程三大特性：2、可见性（什么是可见性、解决可见性的方式）
Arden的博客
05-17 466
可见性问题是基于CPU位置出现的，CPU处理速度非常快，相对CPU来说，去主内存获取数据这个事情太慢了，CPU就提供了L1，L2，L3的三级缓存，每次去主内存拿完数据后，就会存储到CPU的三级缓存，每次去三级缓存拿数据，效率肯定会提升。这就带来了问题，现在CPU都是多核，每个线程的工作内存（CPU三级缓存）都是独立的，会告知每个线程中做修改时，只改自己的工作内存，没有及时的同步到主内存，导致数据不一致问题。可见性问题的代码逻辑// ....System.out.println("t1线程结束");
并发编程（一）可见性
fuyuanduan的博客
11-19 354
volatile保障线程可见性缓存行缓存一致性协议【volatile的底层实现】：volatile除了保障线程可见性之外 ， 它还可以禁止重排序。了解完有序性之后才能真正理解它的底层实现原理。
并发编程-可见性、原子性与有序性
鱼粉大王
04-17 567
内存屏障提供了一套解决CPU缓存优化而导致的顺序性和可见性问题的方案，但是由于不同的硬件系统提供给的“内存屏障”指令都不一样，所以作为软件开发人员来说需要熟悉每个内存屏障的指令实在没必要，所以我们的JAVA语言把不同的内存屏障指令统一进行了封装，让我们的程序员不需要关心到系统的底层，只需要关心他们的自己的程序逻辑开发和如何使用这套规范即可，而封装这套解决方案的模型就是我们常说的Java内存模型JMM(Java Memory Model)重新排序的目的是为了提升CPU的执行效率，合理的利用CPU的等待时间。
并发编程的特性——可见性
qq_41683000的博客
03-18 550
并发编程的特性——可见性
并发编程的三大特性之可见性
舒一笑的博客
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(()->{
jQuery可见性过滤器：hidden和：visibility用法实例
10-24
主要介绍了jQuery可见性过滤器：hidden和：visibility用法,实例分析了：hidden和：visibility的功能及相关使用技巧,需要的朋友可以参考下
juqery 学习之三 选择器 可见性 元素属性
09-05
- `:hidden` 选择器：这个选择器用于选取页面上所有不可见的元素，包括样式设置为 `display:none` 或 `visibility:hidden` 的元素，以及 `type="hidden"` 的输入元素。例如，`$("tr:hidden")` 将选取所有隐藏的 `...
Java并发性编程（阿里巴巴)培训ppt
03-12
Java并发性编程是Java开发中的重要领域，尤其是在大型企业如阿里巴巴这样的公司中，高效地处理多线程环境下的任务是至关重要的。这份“Java并发编程（阿里巴巴）.ppt”很可能包含了关于如何在Java中安全、高效地进行...
block-visibility:所有WordPress区块的条件可见性控件
04-30
区块可见性 使您可以动态控制WordPress网站上可见的块以及谁可以看到它们，其中包括计划块的功能。 该插件是为新的Block（Gutenberg）编辑器而构建的，旨在与任何WordPress块一起使用。 这包括WordPress本身提供的块...
vulkan 可见性剔除算法
10-18
在大型3D场景中，可见性剔除（Visibility Culling）是一项关键技术，它有助于减少渲染计算量，提高性能。通过剔除那些在相机视野之外或被其他物体遮挡的物体，可以显著降低GPU的负担。 Vulkan 中的可见性剔除通常...
并发编程之可见性、并发、并行
未知的希望，是我不灭的信仰
10-31 285
并发编程之并发、并行、可见性
微信小程序总结1--display:none和visible:hidden
scc_722的博客
02-24 2770
1。display:none和visible:hidden都能把网页上某个元素隐藏起来。 2、但两者有区别: ●display:none —不为被隐藏的对象保留其物理空间，即该对象在页面上彻底消失，通俗来说就是看不见也摸不到。 ●visible:hidden— 使对象在网页上不可见，但该对象在网页上所占的空间没有改变，通俗来说就是看不见但摸得到。 1、visibility: hidden----将...
Java并发编程之可见性分析 volatile
m0_73311735的博客
11-18 1271
例如，线程A和线程B，它们都是直接修改主内存中的共享变量，无论是线程A修改了共享变量，还是线程B修改了共享变量，则另一个线程从主内存中读取出来的变量值，一定是修改过的值，这就是线程的可见性。这些线程都是运行在同一个CPU上，操作的是同一个CPU的缓存，只要其中一个线程修改了共享变量的值，那另外的线程就一定能够访问到修改后的变量值。例如，上面的图中，由于CPU是多核的，线程A操作的是CPU-01上的缓存，线程B操作的是CPU-02上的缓存，此时，线程A对变量V的修改对线程B是不可见的，反之亦然。
并发线程特性-可见性和有序性
qq_45309297的博客
11-16 273
在Java中，.java文件中的内容会被编译，在执行前需要再次转为CPU可以识别的指令，CPU在执行这些指令时，为了提升执行效率，在不影响最终结果的前提下（满足一些要求），会对指令进行重排。指令乱序执行的原因，是为了尽可能的发挥CPU的性能。Java中的程序是乱序执行的。b = 0;x = 0;y = 0;a = 1;x = b;});b = 1;y = a;});t1.start();t2.start();t1.join();
visibility:属性
m0_46978034的博客
04-04 2423
visibility: 属性规定元素是否可见 visible　元素可见。 hidden　元素不可见。 collapse　在表格元素中使用时，此值可删除一行或一列，但它不影响表格的布局。被行或列占据的空间会留给其他内容使用。如果此值被用在其他的元素上，会呈现为 “hidden”。 inherit　从父元素继承 visibility 属性的值 你在 html 里面写的东西默认情况下就是属于 visibility:visible; 即元素可见。当某些情况下，你让元素不可见了：visibility:hidde
微信小程序控制元素显示隐藏
每天都想吃好吃的
08-26 1471
2、使用 CSS 样式： 在 WXML 文件中，可以为需要控制显示和隐藏的元素添加一个自定义的类名，并使用 CSS 样式来控制元素的显示和隐藏。在对应的 WXSS 文件中，可以定义相应的 CSS 样式来控制元素的显示和隐藏。属性，并将其设置为一个变量，通过改变该变量的值来控制元素的显示和隐藏。属性： 在 WXML 文件中，可以给需要控制显示和隐藏的元素添加。在微信小程序中，可以通过控制元素的。变量的值，从而控制元素的显示和隐藏。变量的值来控制元素的显示和隐藏。方法，可以改变 isHidden。
并发编程基础知识，java内存模型及多线程、volatile
最新发布
04-29
它关注的是原子性、可见性和有序性这三个关键特性。 1. 原子性（Atomicity）：确保一个操作不会被其他线程中断。对于基本类型的读写操作，Java提供了原子性保证，但在某些特定情况下，如64位的long和double类型在32...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值