原子性

并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

原子性：一个操作或多个操作要么全部执行完成且执行过程不被中断，要么就不执行。

可见性：当多个线程同时访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

有序性：程序执行的顺序按照代码的先后顺序执行。

对于单线程，在执行代码时jvm会进行指令重排序，处理器为了提高效率，可以对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证保存最终执行结果和代码顺序执行的结果是一致的。

看下边的一个例子：

package com.dx.juc.test;public class MyThread implements Runnable {    private int serialNumber = 0;    public void run() {        System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());    }    public int getSerialNumber() {        return serialNumber++;    }}

调用：

package com.dx.juc.test;public class Main {    public static void main(String[] args) {        MyThread thread=new MyThread();        for(int i=0;i<10;i++){            new Thread(thread).start();        }    }}

输出结果（有时会抛出下边异常结果，但不是每次都出现异常结果）：

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

上边这个操作错误的原因：

1）初始值serialNumer=0，thread-0把该值复制到自己的工作空间（线程私有的，该工作空间也可以叫做缓存），之后进行了三个操作：

操作一：int temp=serialNumber;// 从主存中将serialNumber复制到自己的工作空间

操作二：serialNumber=serialNumber+1;// 在自己的工作空间内进行运算

操作三：将serialNumber刷新到主存中

2）假设thread-0在操作三还未处理之前，thread-1从主存中复制serialNumber=0到自己的工作空间，然后thread-0触发操作三，而此时thread-1并不知道主存中的serialNumber已经被修改，它依然使用工作空间中的serialNum=0，也进行与thread-0一样的散步操作。

当thread-1触发操作三时（此时thread-0已经把主存中的serialNubmer修改为1）并不知道serialNumber是否被其他线程操作过，它就把在自己工作区修改的结果刷新到主存中，此时thread-1中的serialNum=1，之后的操作就是thread-1的值覆盖了thread-0的值，实际上他们值是一样的。

3）即时把int serialNumber添加上volatile修饰也不能避免该问题，从这里可以看出volatile是不具有原子性的。

在java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断，要么执行，要么不执行。

X=10;   // 原子性（简单的读取、将数字赋值给变量）Y = x;  // 变量之间的相互赋值，不是原子操作X++;    // 对变量进行计算操作，此时讲过三次操作int temp=X;X=X+1;X=temp,经过获取、修改、赋值三个操作。X = x+1;

语句2实际包括两个操作，它先要去读取x的值，再将y值写入，两个操作分开是原子性的，合在一起就不是原子性的。

语句3、4:x++  x=x+1包括3个操作：读取x的值，x+1，将x写入，所以他们也不是原子性的。

只有语句1具有原子性。

注：可以通过 synchronized和Lock实现原子性。因为synchronized和Lock能够保证任一时刻只有一个线程访问该代码块。

使用Atomic解决原子性问题

在jdk1.5以后java.util.concurrent.atomic包下，提供了

大量的原子变量，它们内部使用CAS算法。

针对上边的代码修改为如下：

package com.dx.juc.test;import java.util.concurrent.atomic.AtomicInteger;public class MyThread implements Runnable {    private AtomicInteger serialNumber = new AtomicInteger();    public void run() {        System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());    }    public int getSerialNumber() {        return serialNumber.getAndIncrement();    }}

将int serialNumber修改AtomicInteger serialNumber就具有原子性，也不在出现异常结果。

CAS算法

CAS（Compare-And-Swap）是一种硬件对并发的支持，针对多处理器操作而设计的，处理器中的一种特殊指令，用于管理对共享数据的并发访问。

CAS是一种无锁的非阻塞算法实现，是硬件对于并发操作的支持，保证了数据变量的原子性。

Cas包含了3个操作数：

1. 内存值 V
2. 预估值 A
3. 更新值 B

当且仅当 V == A 时， V = B; 否则，不会执行任何操作。

简单的来说，CAS有3个操作数，要读写的内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则返回V（不做任何操作，然后重新获取主存V值，重新操作。）。这是一种乐观锁的思路，它相信在它修改之前，没有其它线程去修改它。

CAS算法模拟：

模拟代码：

package com.dx.juc.test;public class TestCompareAndSwap {    public static void main(String[] args) {        final CompareAndSwap cas = new CompareAndSwap();        for (int i = 0; i < 10; i++) {            new Thread(new Runnable() {                public void run() {                    int expectedValue = cas.getValue();                    boolean b = cas.compareAndSet(expectedValue, (int) Math.round(1000));                    System.err.println(b);                }            }).start();        }    }}/** * 默认CAS **/class CompareAndSwap {    // 内存值    private volatile int value = 0;    // 返回内存值    public synchronized int getValue() {        return value;    }    /**     * 如果预估值与原来的值一直，则修改内存为新的值，否则，不做处理。 无论是否修改，都返回原来的内存值。     **/    public synchronized int compareAndSwap(int expectedValue, int newValue) {        int oldValue = value;        if (expectedValue == oldValue) {            value = newValue;        }        return oldValue;    }    // 如果更新成功，舊的內內存值和預估值相等。    public synchronized boolean compareAndSet(int expectedValue, int newValue) {        return expectedValue == compareAndSwap(expectedValue, newValue);    }}

输出结果：

falsefalsetruetruetruefalsefalsetruetruetrue