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

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线程安全情况。而引发这个情况的原因，就是变量的原子性问题引起的。

这里我们即使使用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，否则将不做任何操作

下面通过一段代码模拟下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();
    }
}