原子变量和CAS算法简单介绍

原子变量和CAS算法简单介绍

最近又对线程进行了一点复习，做了一点总结，今天写一下原子变量和CAS算法简单介绍

首先我们介绍一下i++的原子性问题
i++的操作实际上是
int temp = i；
i= i+1；
i= temp；

我们以i++为例

public class TestAtomDemo {
    public static void main(String[] args) {
        AtomDemo atomDemo = new AtomDemo();
        //开启10个线程同时i++
        for (int i = 0; i < 10; i++) {
            new Thread(atomDemo).start();
        }

    }
}

class AtomDemo implements Runnable {

    private int serialnumber = 0;

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

        System.out.println(getSerialnumber());
    }

    public int getSerialnumber() {
        return serialnumber++;
    }

}

运行结果可能产生错误，我们开启10个线程应该是结果是9
0
2
0
7
1
8
6
5
4
3

我们来分析一下内存结构
首先JVM一运行，CPU为每一个线程分配一块存储空间，都会从主存中读取数据，现在主存中有serialnumber初始值为0，如果线程一获取了资源，将serialnumber读取到线程一的存储空间上进行serialnumber++计算，因为serialnumber++分为三步进行，当我们执行int temp = serialnumber；serialnumber = serialnumber+1；当我们执行到此处时计算完成在写入主存之前，线程二可能读取到了数据，此时线程二也做了同样的操作，此时同时写入主存打印，就出现了结果中显示的显示同一个结果。（因为我们这个不是原子操作，所以使用volatile无法解决）

我们使用volatile测试

public class TestAtomDemo {
    public static void main(String[] args) {
        AtomDemo atomDemo = new AtomDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(atomDemo).start();
        }

    }
}

class AtomDemo implements Runnable {

    private volatile int serialnumber = 0;

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

        System.out.println(getSerialnumber());
    }

    public int getSerialnumber() {
        return serialnumber++;
    }

}

结果
0
4
3
2
0
1
5
8
7
6
//依旧存在问题

我们使用原子变量解决原子性问题

java.unit.concurrent.automic包下有原子变量
如何解决原子性问题：
1. 原子变量中有volatile关键字，分装的变量都用volitile修饰。（保证内存可见性）
2. 使用CAS（compare-and - swap）算法保证数据的原子性

1. CAS算法是硬件对于操作共享数据的支持
2. CAS包含了三个数
3. 1.内存知 v
4. 2.预估值 a
5. 3.更新的值 b

6. 当且仅当v=a是才把b的值赋值给v，否则不做任何操作。

   我们分析一下CAS算法内存
   首先读取一个内存值v = 0
   在比较替之前会读取，预估的值A = 0；
   进过 ++ 运算B = 1；要把1写进去（CAS执行是同步的（比较和替换））
   当线程二在线程一写之前获取到V = 0；在进行修改之前尧都区就得内存值，此时线程一可能将修改的值写入主存，主存的值为1，线程二读取，预估值为1，此时相较于原来都进来的值v，需要改1，此时V不等于A，不做任何操作。

CAS算法高，是因为如果操作不成功，下一次不会放弃CPU，会立即再一次的更新。所以要比同步锁效率高。

此时我们用原子变量实现

public class TestAtomDemo {
    public static void main(String[] args) {
        AtomDemo atomDemo = new AtomDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(atomDemo).start();
        }

    }
}

class AtomDemo implements Runnable {
//使用原子变量
    private AtomicInteger serialnumber = new AtomicInteger();

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

        System.out.println(getSerialnumber());
    }

    public int getSerialnumber() {
    //调用原子变量的方法实现自增
        return serialnumber.getAndIncrement();
    }

}