java volatile

为什么使用volatile比同步代价更低？
同步的代价， 主要由其覆盖范围决定， 如果可以降低同步的覆盖范围， 则可以大幅提升程序性能。
而volatile的覆盖范围仅仅变量级别的。 因此它的同步代价很低。
volatile原理是什么？
volatile的语义， 其实是告诉处理器， 不要将我放入工作内存， 请直接在主存操作我。（工作内存详见java内存模型）
因此， 当多核或多线程在访问该变量时， 都将直接操作主存， 这从本质上， 做到了变量共享。

Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。Volatile 变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值之间没有约束。因此，单独使用 volatile 还不足以实现计数器、互斥锁或任何具有与多个变量相关的不变式（Invariants）的类（例如 “start <=end”）


volatile的有什么优势？
1， 更大的程序吞吐量
2， 更少的代码实现多线程
3， 程序的伸缩性较好
4， 比较好理解， 无需太高的学习成本
volatile有什么劣势？
1， 容易出问题
2， 比较难设计
volatile运算存在脏数据问题
volatile仅仅能保证变量可见性， 无法保证原子性。

volatile的race condition示例：
public class TestRaceCondition {
    private volatile int i = 0;
    public void increase() {
    i++;
    }
    public int getValue() {
    return i;
    }
}

当多线程执行increase方法时， 是否能保证它的值会是线性递增的呢？
答案是否定的。
原因：
这里的increase方法， 执行的操作是i++， 即 i = i + 1；
针对i = i + 1， 在多线程中的运算， 本身需要改变i的值。
如果， 在i已从内存中取到最新值， 但未与1进行运算， 此时其他线程已数次将运算结果赋值给i.
则当前线程结束时， 之前的数次运算结果都将被覆盖。
即， 执行100次increase， 可能结果是 < 100.
一般来说， 这种情况需要较高的压力与并发情况下， 才会出现。
解决以上问题的方法：
一种是 操作时， 加上同步。 这种方法， 无疑将大大降低程序性能， 且违背了volatile的初衷。
第二种方式是， 使用硬件原语（CAS）， 实现非阻塞算法


正确使用 volatile 变量的条件
您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：
    * 对变量的写操作不依赖于当前值。
    * 该变量没有包含在具有其他变量的不变式中。
实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。
第一个条件的限制使 volatile 变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。实现正确的操作需要使 x 的值在操作期间保持不变，而 volatile 变量无法实现这点。（然而，如果将值调整为只从单个线程写入，那么可以忽略第一个条件。）
大多数编程情形都会与这两个条件的其中之一冲突，使得 volatile 变量不能像 synchronized 那样普遍适用于实现线程安全。清单 1 显示了一个非线程安全的数值范围类。它包含了一个不变式 —— 下界总是小于或等于上界。

清单 1. 非线程安全的数值范围类
                
@NotThreadSafe
public class NumberRange {
    private int lower, upper;

    public int getLower() { return lower; }
    public int getUpper() { return upper; }

    public void setLower(int value) {
        if (value > upper)
            throw new IllegalArgumentException(...);
        lower = value;
    }

    public void setUpper(int value) {
        if (value < lower)
            throw new IllegalArgumentException(...);
        upper = value;
    }
}

这种方式限制了范围的状态变量，因此将 lower 和 upper 字段定义为 volatile 类型不能够充分实现类的线程安全；从而仍然需要使用同步。否则，如果凑巧两个线程在同一时间使用不一致的值执行 setLower 和 setUpper 的话，则会使范围处于不一致的状态。例如，如果初始状态是 (0, 5)，同一时间内，线程 A 调用 setLower(4) 并且线程 B 调用 setUpper(3)，显然这两个操作交叉存入的值是不符合条件的，那么两个线程都会通过用于保护不变式的检查，使得最后的范围值是 (4, 3) —— 一个无效值。至于针对范围的其他操作，我们需要使 setLower() 和 setUpper() 操作原子化 —— 而将字段定义为 volatile 类型是无法实现这一目的的。