Java并发编程中的底层原理

阅读《深入浅出Java Concurrency》过程中的个人理解
原文：http://www.blogjava.net/xylz/archive/2010/07/08/325587.html
这篇博客写的相当好，真正做到深入浅出

---

原子操作

平常编程中类似i++的操作并非一个原子操作；
可以使用：
AtomicInteger AtomicIntegerArray

指令重排序

JVM只保证程序最终结果等同于顺序时的结果，指令的实际执行顺序与代码顺序可能不一致。意义是根据处理器的特点，进行适当的重排序可以提高性能。

happens-before法则

如果action b要看到action a的执行结果，那么ab需要满足happans-before的关系；
一个动作（Action）包括：变量的读写、监视器加锁和释放锁、线程的start()和join()；

volatile语义

• 禁止重排序和可见性
  可见性：每次从主存中读取变量（详见java内存模型）；根据happens-before法则，volatile变量的写操作后，其后的任何读操作立即可见此写操作的结果；
• 使用volatile的原则
  写变量不依赖变量此时的值
  变量的状态不需要与其它变量共同参与不变约束 (?)

CAS

campare and swap，需要配合volatile一起使用

//++i
private volatile int value;
public final int get() {
        return value;
    }
public final int incrementAndGet() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}

底层使用Unsafe包中的native函数

public final boolean compareAndSet(int expect, int update) {   
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

会产生aba问题，比如对链表中节点的更改；解决方法是每次修改后更新时间戳；

AQS

concurrent包中大多数操作都是基于AQS

ReentrantLock.lock（）

若获取失败则禁用当前线程，进入休眠状态；

• 公平锁&非公平锁

如果获取一个锁是按照请求的顺序得到的，那么就是公平锁，否则就是非公平锁。非公平锁可以利用休眠线程恢复的这段时间，性能更好；

对于公平锁，lock()就直接调用AQS的acquire(int arg)，以独占模式获取对象；

acquire的过程是这样的：首先尝试获取锁（tryAcquire），若不成功则创建一个独占节点加入CHL队列，接着进行自旋尝试获取锁（即不断尝试tryacquire，挂起时间根据上一个节点决定），直到获取到锁对象，如果当前线程已经中断过，那么就中断当前线程（清除中断位）

tryAcquire的过程是这样的：若锁未被任何线程获取且队列为空或当前线程在队列头部，则获得该锁；若锁原本就被该线程获取，则计数器加一；其他情况则返回false；

对于非公平锁，不需要判断当前节点是否在头部；

ReentrantLock.unlock（）

调用了AQS的release操作；

释放相应的资源，并且唤醒AQS队列中有效的继任节点

Condition

条件变量很大程度上是object.wait()/nodify()的替代品

获取锁之后若不满足特定条件，则调用await，释放锁，等待被其他线程signal唤醒

调用await之后，线程会加入Condition锁队列（该队列是否为fifo取决于锁是否公平），然后释放锁，并自旋；