2.JUC线程高级-原子变量与CAS算法

  1. 云栖社区>
  2. 博客>
  3. 正文

2.JUC线程高级-原子变量与CAS算法

潘天涯 2018-09-04 16:46:00 浏览563
展开阅读全文

1.变量原子性引发的问题

这里我们通过一个很经典的案例i++来分析下原子性问题

   int i = 10;
   i = i++;
   此时i的值为:10 

执行完i++后为什么结果是10,原因是因为i++操作,jvm底层实际是分为以下三步:(读-改-写)

int temp = i;
i = i + 1; 
i = temp;

2.模拟原子性异常情况

package com.pyy.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 serialNumber = 0;

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    public int getSerialNumber() {
        return serialNumber++;
    }
}

结果:

Thread-3:0
Thread-1:8
Thread-2:7
Thread-7:3
Thread-5:0
Thread-6:2
Thread-4:1
Thread-0:6
Thread-9:5
Thread-8:4

通过结果我们发现出现 多个0线程安全情况。而引发这个情况的原因,就是变量的原子性问题引起的。

img_e23242a19ba01480b257b4666ab2baad.png

这里我们即使使用volatile修饰变量,但依次存在线程安全问题。原因就是因为 i++操作被jvm底层拆分成三部读-写-改操作。

虽然volatile 修饰后变量的修改(都在主存中执行)但由于原子性的问题,导致变量分步修改过程中其它线程读到了修改之前的变量值。

3. 解决原子性问题-原子变量AtomicXxx

JDK1.5之后,java.util.concurrent.atomic 包下提供了常用的原子变量AtomicXxx:

  1. 使用volatile 保证内存可见性
  2. 使用CAS(Compare-And-Swap) 算法保证数据的原子性

CAS 算法其实是硬件对于并发操作共享数据的支持

CAS 包含了三个操作数:
内存值:V
预估值:A
更新值:B
当且仅当 V==A 时,V = B,否则将不做任何操作

img_52052ae5f3bcc76c3a7bdd2e6b7c3ac1.png

下面通过一段代码模拟下CAS:

/*
 * 模拟CAS算法
 */

class CAS {
    // 内存值
    private volatile int value;

    // 获取内存值
    public synchronized 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);
    }
}

public class TestCAS {

    public static void main(String[] args) {

        CAS cas = new CAS();

        //创建10个线程来模拟多线程环境
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    int expectedValue = cas.getValue();
                    boolean b = cas.compareAndSet(expectedValue, (int) (Math.random() * 101));
                    System.out.println(b);
                }
            }).start();
        }
    }
}

CAS算法之所以要比之前使用synchronized的效率高,是因为这次如果不成功,它不会放弃cpu执行权,会紧接着多次尝试,直到修改完毕。
代码使用AtomicXxx重构完毕后(解决变量原子性问题):

package com.pyy.juc;


import java.util.concurrent.atomic.AtomicInteger;

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 int serialNumber = 0;
    private AtomicInteger serialNumber = new AtomicInteger();


    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    public int getSerialNumber() {
        //return serialNumber++;
        return serialNumber.getAndIncrement();
    }
}

网友评论

登录后评论
0/500
评论
潘天涯
+ 关注