扫一扫下方二维码,关注本站官方公众号
回复:2020加油
获取永久解锁本站全部文章的验证码

从内存可见性看Volatile、原子变量和CAS算法-Go语言中文社区

从内存可见性看Volatile、原子变量和CAS算法


【1】内存可见性与内存可见性错误

内存可见性(Memory Visibility)是指当某个线程正在使用对象状态而另一个线程在同时修改该状态,需要确保当一个线程修改了对象状态后,其他线程能够看到发生的状态变化。

那么如果一个线程修改了对象状态,其他线程看不到对象的状态变化怎么办?就会引起内存可见性错误!

可见性错误是指当读操作与写操作在不同的线程中执行时,我们无法确保执行读操作的线程能适时地看到其他线程写入的值,有时甚至是根本不可能的事情。

实例如下:

public class TestVolatile {

    public static void main(String[] args){

        ThreadDemo td=new ThreadDemo();
        new Thread(td).start();

        while (true){
            if (td.isFlag()){
                System.out.println("----------------------");
                break;
            }
        }

    }
}

class ThreadDemo implements  Runnable{

    private boolean flag = false;

    @Override
    public void run() {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag=true;
        
        System.out.println("flag= "+flag);

    }

    public boolean isFlag(){
        return this.flag;
    }

    public void setFlag(boolean flag){
        this.flag=flag;
    }
}

有两个线程,main线程和新起的new Thread(td),当主线程while循环中判断td.flag为true时,则打印横线并跳出循环。

测试结果如下:

这里写图片描述

并不会打印横线并终止main的while循环!但是已经打印了flag= true说明td.flag状态已经改变。这就是内存可见性错误!!


分析如下:

当程序运行时,JVM为会每一个线程分配独立的缓存提高效率。共享数据flag=false当然是存在JVM内存中(确切的说,是随对象存储在堆里面)。线程将会将数据读取到自己缓存进行利用,更改后同步更新JVM内存中的数据。

如下图所示:

这里写图片描述

由图可见,线程一new Thread(td)会去读取flag并进行修改然后再“反映”到JVM内存中的flag。那么为什么main里面的while循环一直拿不到更新后的true?

这里需要注意两点:

  • new Thread(td)的run方法里面先Thread.sleep(200);while (true)先执行了;
  • while (true){}调用了一系列的底层代码执行效率非常高,高到main没有机会获取内存中更新后的flag。

如何解决呢?

可能会说,使用同步代码块,如下:

 public static void main(String[] args){

        ThreadDemo td=new ThreadDemo();
        new Thread(td).start();

        while (true){
         //这里使用synchronized 关键字,锁为td
            synchronized (td){
                if (td.isFlag()){
                    System.out.println("----------------------");
                    break;
                }
            }

        }
    }

synchronized 能保证每次都刷新缓存,当然可以获取到对象的最新状态,结果如下:

这里写图片描述

但是需要注意的是,synchronized 会降低性能,如果有多个线程呢?当前线程拿到锁执行代码,其他线程过来肯定要阻塞等待CPU下次调度。

我们可以通过同步来保证对象被安全地发布。除此之外我们也可以使用一种更加轻量级的volatile 变量。

这里推荐使用Volatile !

volatile能保证多个线程进行操作共享数据时,内存中的数据对彼此是可见的。如果一个变量加了volatile关键字,就会告诉编译器和JVM的内存模型:这个变量是对所有线程共享的、可见的,每次jvm都会读取最新写入的值并使其最新值在所有CPU可见。


【2】Volatile与Synchronized

Java提供了一种稍弱的同步机制,即volatile 变量,用来确保将变量的更新操作通知到其他线程。你可以将volatile 看做一个轻量级的锁。

修改代码如下:

public class TestVolatile {

    public static void main(String[] args){

        ThreadDemo td=new ThreadDemo();
        new Thread(td).start();

        while (true){
//            synchronized (td){
                if (td.isFlag()){
                    System.out.println("----------------------");
                    break;
                }
//            }
        }
    }
}

class ThreadDemo implements  Runnable{
	// 这里,使用volatile修饰flag
    private volatile boolean flag = false;

    @Override
    public void run() {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag=true;
        
        System.out.println("flag= "+flag);

    }

    public boolean isFlag(){
        return this.flag;
    }

    public void setFlag(boolean flag){
        this.flag=flag;
    }
}

测试结果如下:

这里写图片描述


那么是否说明volatile比Synchronized更好,能替代Synchronized?

完全错误!!!

如上所说,volatile是一种轻量级的锁,synchronized是重量级锁(悲观锁),volatile与synchronized区别如下:

  • 对于多线程,不是一种互斥关系;
    synchronized是保证互斥的,即拿到锁的线程可以执行,其他线程过来只能等待;volatile不能保证这种关系。

  • 不能保证变量状态的“原子性操作”。

  • 不要将volatile用在getAndOperate场合(这种场合不原子,需要再加锁),仅仅set或者get的场景是适合volatile的。

那么什么是“原子性操作”?volatile不能保证变量的“原子性”操作会出现什么问题?


【3】原子性操作

① 经典例子i++

代码如下:

 @Test
  public void test1(){
       int i=10;
       i=i++;
       System.out.println(i);//i=10
   }

编译后class文件中对应代码如下:

 @Test
 public void test1() {
     int i = 10;
     byte var10000 = i;
     int var2 = i + 1;
     i = var10000;
     System.out.println(i);
 }

使用javap -verbose Test.class查看对应指令如下:

 public void test1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=1
         0: bipush        10
         2: istore_1
         3: iload_1
         4: iinc          1, 1
         7: istore_1
         8: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        11: iload_1
        12: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        15: return
      LineNumberTable:
        line 22: 0
        line 23: 3
        line 24: 8
        line 25: 15
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      16     0  this   Lcom/jane/TestRex;
            3      13     1     i   I
    RuntimeVisibleAnnotations:
      0: #17()

也就是说i++的操作实际上分为三个步骤“读-改-写”(对应指令中的 3 ,4 ,7)。原子性操作就是这三个步骤为一个"单元",在执行这个"单元"过程中,其他线程不能过来干涉。


② volatile不能保证变量的原子操作

示例如下:

public class TestAtomicDemo {

    public static void main(String[] args){

        AtomicDemo ad = new AtomicDemo();
        for (int i=0;i<10;i++){
            new  Thread(ad).start();
        }
    }
}

class AtomicDemo implements  Runnable{
	// 这里使用volatile修饰
    private volatile int serialNum = 0;

    @Override
    public void run() {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+" : "+getSerialNum());

    }

    public int getSerialNum() {
       // 这里 serialNum++
        return serialNum++;
    }
}

多次运行测试,会出现多线程问题,如下图:

这里写图片描述

由于volatile对于多线程不具有互斥性,不能保证变量的原子操作,故而如线程一读取并修改serialNum时,线程二、线程三也可能要修改!

那么如何实现变量的原子性操作?

这就涉及到了原子变量和CAS算法。


【4】原子变量

JDK1.5后提供了java.util.concurrent工具包。该包为类的小工具包,支持在单个变量上解除锁的线程安全编程。

事实上,此包中的类可将volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。

java.util.concurrent.atomic 包下提供了一些原子操作的常用类:

这里写图片描述

类AtomicBoolean、AtomicInteger、AtomicLong 和AtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。

AtomicIntegerArray、AtomicLongArray 和AtomicReferenceArray 类进一步扩展了原子操作,对这些类型的数组提供了支持。这些类在为其数组元素提供volatile 访问语义方面也引人注目,这对于普通数组来说是不受支持的。

参考博文:JUC中原子类总结

修改代码如下:

public class TestAtomicDemo {

    public static void main(String[] args){

        AtomicDemo ad = new AtomicDemo();
        for (int i=0;i<10;i++){
            new  Thread(ad).start();
        }
    }
}

class AtomicDemo implements  Runnable{

//    private volatile int serialNum = 0;

    private AtomicInteger ai=new AtomicInteger();

    @Override
    public void run() {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+" : "+getSerialNum());

    }

    public int getSerialNum() {
//        return serialNum++;
        return ai.getAndIncrement();
    }

测试多次运行测试,不会出现多线程的错误!

为什么使用原子变量就可以避免如上所示的多线程错误?有两点需要注意:

  • 变量使用volatile修饰保证内存可见性;
  • CAS算法保证数据的原子性。

以AtomicInteger为例,除了final修饰的常量外,变量使用volatile修饰:

这里写图片描述

那么,什么是CAS算法?


【5】CAS算法

CAS (Compare-And-Swap) 是一种硬件对并发的支持,针对多处理器操作而设计的处理器中的一种特殊指令,用于管理对共享数据的并发访问。其实,CAS 是一种无锁的非阻塞算法的实现。Java中的CAS操作依赖于底层CPU的CAS指令。

CAS 包含了3 个操作数:

  • 需要读写的内存值V
  • 进行比较的值A
  • 拟写入的新值B

当且仅当V 的值等于A 时,CAS 通过原子方式用新值B 来更新V 的值,否则不会执行任何操作。

这也就是为什么【4】中的代码不会出现多线程的错误。

当某个线程尝试进行更新主存中的数据时,会再次读取数据–A,然后将V与A比较,V==A则执行更新,否则放弃。在同一个时刻,将会只有一个线程更新JVM中的数据成功!


使用如下代码模拟计算机底层CAS操作:

public class TestCompareAndSwap {

    public static void main(String[] args){
        final CompareAndSwap compareAndSwap = new CompareAndSwap();

        for (int i=0;i<10;i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 获取主存值
                    int expectedValue = compareAndSwap.getValue();
                    boolean b = compareAndSwap.compareAndSet(expectedValue, (int) (Math.random() * 101));
                    System.out.println(b);

                }
            }).start();
        }

    }

}

class CompareAndSwap{

    private  int value;

    //获取主存值
    public int getValue() {
        return value;
    }

    // 比较并设置,返回主存值
    public synchronized  int compareAndSwap(int expectedValue,int newValue){
        int oldValue = value;

        //如果主存值==预估值,则进行更新
        if (oldValue==expectedValue){
            this.value=newValue;
        }
        return oldValue;
    }

    //调用设置值方法,并返回成功失败
    public synchronized boolean compareAndSet(int expectedValue,int newValue){
        return expectedValue==compareAndSwap(expectedValue,newValue);
    }
}

那为什么CAS比锁性能要高呢?

如果使用了锁,该次不成功的情况下将会阻塞,等待下一次CPU调度;但是CAS如果该次失败了,会立即尝试进行下一次!

它允许多线程非阻塞式地对共享资源进行修改,但同一时刻只有一个线程能够成功,其他线程被告知失败但并不会挂起,而是重新尝试。这是一种非阻塞式的同步方式。


【6】CAS指令

java中给我们提供了本地方法来获得和CAS指令一样的执行效果。比如Unsafe类中:

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

因为这些方法会被编译成平台相关的CAS指令,故而这些CAS操作都具有原子性。但是这些CAS操作我们无法直接使用,因为只有Bootstrap ClassLoader(JVM内置类加载器)加载的Class才能访问它。

在JDK并发包的底层实现中,还是可以处处看到它的身影。如下图所示:

这里写图片描述


【7】CAS结合失败重试机制进行并发控制

还记得【4】中的代码修改之后就不会出现多线程错误:

class AtomicDemo implements  Runnable{

//    private volatile int serialNum = 0;

    private AtomicInteger ai=new AtomicInteger();

    @Override
    public void run() {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+" : "+getSerialNum());

    }

    public int getSerialNum() {
//        return serialNum++;
        return ai.getAndIncrement();
    }

CAS指令只是提供了一个更新变量的原子操作,要使用它进行并发控制,还需要结合失败重试机制。

查看ai.getAndIncrement();源码如下:

跟踪到AtomicInteger类中:

 /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

继续跟踪到Unsafe类中:

 public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
            //获取当前变量值
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
        //CAS失败则重新尝试直到成功为止

        return var5;
    }

可以看到步骤可以概括为

  • 1.获得变量当前的值var5
  • 2.使用CAS操作进行更新:若var5与当前的值不一样,说明1,2操作间有其他线程作了修改,此次更新失败,重新实行步骤1;否则用 var5+var4的值进行更新,并返回更新前的值。

多个线程同时使用CAS指令去更新变量,失败的线程将会不断重新尝试,直到更新成功。


【8】CAS优缺点

① 优点

没有线程阻塞唤醒带来的性能消耗问题。这也是为什么比synchronized性能高的原因!

② 缺点

  • ABA问题。

在CAS操作时,我们以变量的当前值和预期值一致来判定变量未被其他线程修改。这样是不严谨的,因为变量可能被修改成其他值后又被改了回来,大部分时候这是个可以忽略的小问题,如果要规避这个问题,可以使用AtomicStampedReference,它会额外使用一个时间戳来判断变量是否被修改过。

  • 无法直接使用CAS来进行并发控制,相比同步锁的方式适用范围较窄。

【8】经典例子i++的几种情况

① 单独a++

如下所示:

//源码
@Test
public void contextLoads5() {
	int a=5;
	a++;
	System.out.println(a);
}
//编译后
@Test
  public void contextLoads5() {
       int a = 5;
       a = a + 1;
       System.out.println(a);
   }

此时毫无疑问,a==6。


② a++赋值给自身

如下所示:

//源码
@Test
public void contextLoads4() {
	int a=5;
	a=a++;
	System.out.println(a);
}
//编译后
@Test
 public void contextLoads4() {
     int a = 5;
     byte var10000 = a;
     int var2 = a + 1;
     a = var10000;
     System.out.println(a);
 }

此时 a仍旧等于5。


③ a++赋值给其他

如下所示:

//源码
@Test
public void contextLoads6() {
	int a=5;
	int b=a++;
	System.out.println(a);
	System.out.println(b);
}
//编译后
@Test
public void contextLoads6() {
      int a = 5;
      byte var10000 = a;
      int a = a + 1;
      int b = var10000;
      System.out.println(a);
      System.out.println(b);
  }

此时a==6,b==5


④ a++与其他运算符结合

如下所示:

//源码
@Test
public void contextLoads3() {
	int a=5;
	int b=a++;
	int c=b*a++;
	System.out.println(a);
	System.out.println(b);
	System.out.println(c);
}

此时 a==7,b==5,c==30


⑤ ++a与其他运算符结合

如下所示:

@Test
public void contextLoads3() {
	int a=5;
	int b=++a;
	int c=b*++a;
	System.out.println(a);
	System.out.println(b);
	System.out.println(c);
}

此时 a==7,b==6,c==42


⑥ a++与++a和其他运算符结合

如下所示:

@Test
public void contextLoads3() {
	int a=10>>1;
	int b=a++;
	int c=++a;
	int d=b*a++;
	System.out.println(a);
	System.out.println(b);
	System.out.println(c);
	System.out.println(d);
}

此时 a==8,b==5,c==7,d==35

版权声明:本文来源CSDN,感谢博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
原文链接:https://blog.csdn.net/j080624/article/details/52845752
站方申明:本站部分内容来自社区用户分享,若涉及侵权,请联系站方删除。

0 条评论

请先 登录 后评论

官方社群