JAVA多线程-(四)并发编程三大特性之可见性volatile

努力的布布

已于 2022-04-30 16:48:08 修改

阅读量505

点赞数

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

于 2022-04-19 22:55:14 首次发布

本文链接：https://blog.csdn.net/qq_37200262/article/details/124281264

版权

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

20 篇文章 2 订阅

订阅专栏

并发编程三大特性

可见性
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
 *
 * @author mashibing
 */
package com.juc.c_001_01_Visibility;

import com.util.SleepHelper;

import java.io.IOException;

public class T01_HelloVolatile {//volatile 保持可见性
    private static volatile boolean running = true;

    private static void m() {
        System.out.println("m start");
        while (running) {//running变量不被volatile修饰 在线程启动运行的时候是从主内存读取m到线程本地，
                        // 后面主线程对running修改不会同步到线程中的running变量 该线程看不到
            //volatile修饰的变量每次读的时候都会从主内存读一遍 变量有改动 下次线程读取从主存读取就会获取到最新的变量 主存修改会同步到线程
            //System.out.println("hello");//放开该注释 即使变量不被volatile修饰 主线程修改后也会被同步到这个线程，
                                       // 因为System.out.println有个synchronized关键字 synchronized也可保持可见性 某些语句执行 触发本地缓存和线程缓存进行数据刷新和同步
        }
        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;

        System.in.read();
    }
}

volatile 引用类型

/**
 * volatile 引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段的可见性
 */
package com.mashibing.juc.c_001_01_Visibility;

import com.mashibing.util.SleepHelper;

public class T02_VolatileReference {

    private static class A {
        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;//volatile 引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段的可见性
        // ,如果想保证可见性 就要把对象内的属性加上volatile修饰
    }


}

存储器的层析结构
在这里插入图片描述
寄存器需要数据，先去L1-> L2-> L3, L3没有就去主存 ;读数据先往L3存，然后L2 ，L1 。

可见性指的是在多核CPU 中，主存的数据，在不同核的三级缓存中主存改变了，每个核的其他缓存也可见。

按块读取
程序局部性原理，可以提高效率，充分发挥总线 CPU针脚等一次性读取更多数据的能力。
空间局部性原理:读到一个数据，相邻的数据也会一次性读到缓存一次读取一整块数据一整块就是缓存行cach line 一个缓存行大小是64字节；
时间局部性原理: 读取指令的时候把很多指令的数据一次性读取到缓存。
访问一个数据会把xy全部缓存进来既然xy在cpu1和CPU2 ，采用缓存一致性协议保证CPU1和CPU2的xy保持一致性，当x修改缓存行通知cpu把数据从内存刷新到缓存，正是由于这个机制多线程修改的东西在同一行的时候会互相干扰。

package com.mashibing.juc.c_001_02_FalseSharing;

import java.util.concurrent.CountDownLatch;

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

    private static class T {
        //private long p1, p2, p3, p4, p5, p6, p7;
        public long x = 0L; //8bytes 8个long就沾满一个缓存行大小
        //private long p9, p10, p11, p12, p13, p14, p15;
    }

    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);
    }
}

放开class T的两行注释，会发现运行时间会更快。因为放开注释之前，两个对象很大可能在同一个缓存行，因为缓存一致性协议，两个对象任何一个的数据发生变化，缓存行都会同步这个缓存行的数据去主存拿最新的，即使自己的数据没有变，因为在同一个缓存行，旁边的数据变了，这个线程所在的缓存也要去更新数据，所以会慢。通过前后填充7个long，一共8个long，64字节，每一个对象占据一个缓存行，所以减少互相之间的干扰，会变得快。

Disruptor单机性能最高的mq 环形缓冲区
在这里插入图片描述

采用填充的形式，沾满缓存行，提高性能。

@Contended
保证x位于单独一行中不会和别的位于一个缓冲行
运行这个小程序的时候，需要加参数：-XX:-RestrictContended

package com.juc.c_001_02_FalseSharing;


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);
    }
}