一、构建自定义的同步工具
1. 内置的条件队列
条件队列就如同烤面包机上的面包已好的铃声。如果你正在听着它, 当面包烤好后你可以立即注意到, 并且放下手头的事情开始品尝面包, 如果你没有听见它, 你会错过通知消息, 但是回到厨房后还是看到面包的状态, 如果已经烤完, 就取面包, 如果未烤完, 就再次监听铃声。
条件队列中的元素是一个个正在等待相关条件的线程。每一个对象都可以作为一个条件队列，并且Object的wait，notify和notifyAll构成了内部条件队列的API。
wait：wait是等待的意思，调用wait会自动释放锁，并请求系统挂起当前线程，从而使其他线程能够获得这个锁
notify：发出通知，解除阻塞条件，JVM会从这个条件队列上等待的多个线程选择一个来唤醒
notifyAll：发出通知，解除阻塞条件，JVM会唤醒所有在这个条件队列上等待的线程
条件谓语：线程等待的条件
条件等待中存在一个很重要的三元关系：synchronized，wait和一个条件谓语。
条件变量由一个锁保护，检查条件谓语时必须先持有锁，调用wait和notifyAll所在方法的对象必须是同一个对象。
用下面这个代码来解析：
public synchronized V take() throws InterruptedException{
while(isEmpty()){
wait();
}
V v = get();
notifyAll();
return v;
}
在这块代码中，isEmpty就是take（）方法的条件谓语，A线程如果判断为空，将会调用wait，阻塞A线程，直到其它线程B操作使isEmpty为false，接着B调用notifyAll，释放锁后，唤醒线程A。
notify和notifyAll的区别：
大多数情况下，应该优先选择notifyAll。假如线程A在条件队列上等待条件谓语PA，线程B在同一个条件队列上等待条件谓语PB，假如线程C将PB变为真，且调用notify，JVM将从众多的等待线程选择其中A来唤醒，但是A看到PA仍然为false，于是继续等待，然而线程B本可以开始执行，却没有被唤醒。
只有满足一下两个条件时，才能用单一的notify而不是notifyAll：
1. 所有等待线程的类型都相同
2. 单进单出：在条件变量上的每次通知，最多只能唤醒一个线程来执行
如果有10个线程在条件队列中等待, 调用notifyAll会唤醒每一个线程, 让它们去竞争锁, 然后它们中的大多数或者全部又回到休眠状态, 这意味着每一个激活单一线程执行的事件, 都会带来大量的上下文切换, 和大量竞争锁的请求
2. Condition对象
内置的条件队列有一些缺陷，每一个内置锁都只能由一个相关联的条件队列。如果想要编写一个带有多个条件谓语的并发对象，可以使用Lock和Condition。
一个Condition和一个单独的Lock相关联, 调用Lock.newCondition()方法, 可以创建一个Condition。每个Lock可以有任意数量的Condition对象. wait, notify, notifyAll在Condition中都有对应的：await, signal, signalAll, 而且一定要使用后者!
示例：
public class ConditionBoundedBuffer<T> {
private static final int BUFFER_SIZE = 2;
private final Lock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
private final T[] items = (T[]) new Object[BUFFER_SIZE];
private int tail, head, count;
public void put(T x) throws InterruptedException {
lock.lock();
try {
while (count == items.length) {
notFull.await(); //
}
items[tail] = x;
if (++tail == items.length) {
tail = 0;
}
count++;
notEmpty.signal(); //
} finally {
lock.unlock();
}
}
public T take() throws InterruptedException {
lock.lock();
try {
while (count == 0) {
notEmpty.await();//
}
T x = items[head];
items[head] = null;
if (++head == items.length) {
head = 0;
}
count--;
notFull.signal(); //
return x;
} finally {
lock.unlock();
}
}
}
3.AbstractQueuedSynchronizer（AQS）
同步的实现都是基于AbstractQueuedSynchronizer（AQS），AQS是一个用于构建锁和同步器的框架，例如ReentrantLock，Semaphore，CountDownLatch等都是基于AQS构建的。
AQS构建的容器中，最基本的就是获取操作和释放操作，对于CountDownLatch，获取意味着等待并直到闭锁到达结束状态，对于FutureTask，获取意味着等待直到任务已经完成。
AQS负责同步容器类中的状态，它管理了一个整数状态信息，可以通过getState，setState以及compareAndSetState来设置和获取。例如ReentrantLock用它来表示线程已经重复获取该锁的次数，Semaphore用它来表示剩余的许可数量，FutureTask用它来表示任务的状态（尚未开始，正在运行，已完成以及以取消）
AQS获取操作可能是独占的, 就像ReentrantLock一样, 也可能是非独占的, 就像Semaphore和CountDownLatch一样, 这取决于不同的Synchronizer
下面使用AQS来实现一个闭锁：（事实上，同步容器就是这样做的）
public class OneShotLatch {
private final Sync sync = new Sync();
private class Sync extends AbstractQueuedSynchronizer {
@Override
protected int tryAcquireShared(int arg) {
return (getState() == 1) ? 1 : -1;
}
@Override
protected boolean tryReleaseShared(int arg) {
setState(1);
return true;
}
}
public void signal() {
sync.releaseShared(0);
}
public void await() throws InterruptedException {
sync.acquireInterruptibly(0);
}
}
代码中通过AQS管理闭锁的状态：关闭0， 打开1。await方法调用AQS的acqurieSharedInterruptibly, 后者随后请求OneShotLatch中的tryAcquireShared方法必须返回一个值来表明操作能否继续执行. 如果闭锁已经事先打开, tryAcquireShared会返回成功, 并允许线程通过; 否则他会返回一个值, 表明获取请求的尝试失败. acquireSharedInterruptibly方法处理失败的方式, 是把线程植入一个队列中, 该队列中的元素都是等待中的线程, signal调用releaseShared, 进而导致tryReleaseShared被调用. tryReleasseShared的实现无条件地把闭锁的状态设置为打开, 通过返回值表明Synchronizer处于完全释放的状态
4.java.util.concurrent同步类中的AQS
java.util.concurrent同步类都没有直接扩展AQS，而是将他们的功能委托给AQS子类实现。
java.util.concurrent中基于AQS开发的类有：ReentrantLock，Semaphore，ReentrantReadWriteLock，CountDownLatch，SynchronousQueue和FutureTask等。
二、原子变量和非阻塞同步机制
非阻塞算法被广泛用于操作系统和JVM中实现线程/进程调度机制，垃圾回收机制以及锁和其它并发数据结构。
1. 比较并交换（CAS）
概念：
1. 比较并交换有三个操作数: 内存位置V，进行比较的值A，新值B
2. 当且仅当V的值等于旧值A时, CAS才会用新值B原子化地更新V的值, 否则它什么都不会做。
3. 无论位置V的值是否等于A，CAS都会返回V的真实值。CAS的意思是: 我认为V的值应该是A, 如果是, 那么将B值赋值给V, 若不是, 则不修改, 并告诉我V的旧值为多少。
4. CAS是一项乐观技术: 它抱着成功的希望进行更新, 并且如果另一个线程在上次检查后更新了该变量, 它能够发现错误
5. 当多个线程试图使用CAS同时更新相同的变量时, 只有一个线程会更新变量的值，而其他的都会失败。然而，失败的线程不会被挂起, 他们会被告知这次赛跑失利, 但是允许重试。由于一个线程不会竞争CAS时不会被阻塞，因此它可以决定是否重试。
CAS的典型使用模式：
首先从V中读取值A，根据A计算值B，然后通过CAS以原子操作将V的值A变为B。
一个模拟的CAS：
public class SimulateCAS {
private int value;
public synchronized int get() {
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));
}
}
基于CAS实现的线程安全的计数器：
public class CasCounter {
private SimulateCAS value = new SimulateCAS();
public int getValue() {
return value.get();
}
public int increment() {
int v;
do {
v = value.get();
} while (v != value.compareAndSwap(v, v + 1));
return v + 1;
}
}
2.非阻塞算法
如果线程在持有锁时由于阻塞IO，内存页缺失或其他延迟导致推迟执行，那么很可能所有的线程都不能继续执行下去。
非阻塞算法：如果在某种算法中，一个线程的失败或者挂起不会导致其他线程也失败或挂起，那么这种算法就被称为非阻塞算法。
无锁算法：如果在算法的每一个步骤都存在某个线程能够执行下去，那么这种算法称为无锁算法。
无阻塞，无锁算法：如果算法中仅将CAS用于协调线程之间的操作，并且能够正确地实现，那么它是一种无阻塞，无锁算法。
上面基于CAS实现的线程安全的计数器就是无阻塞算法实现
基于非阻塞的Stack实现：
public class ConcurrentStack<E> {
class Node<E> {
E item;
Node<E> next;
public Node(E item) {
this.item = item;
}
}
AtomicReference<Node<E>> top = new AtomicReference<Node<E>>(); // 对栈顶的一个引用
public void push(E item) {
Node<E> newHead = new Node<E>(item);
Node<E> oldHead;
do {
oldHead = top.get();
newHead.next = oldHead;
} while (!top.compareAndSet(oldHead, newHead));
}
public E pop() {
Node<E> oldHead;
Node<E> newHead;
do {
oldHead = top.get();
if (oldHead == null) {
return null;
}
newHead = oldHead.next;
} while (!top.compareAndSet(oldHead, newHead));
return oldHead.item;
}
}
基于非阻塞的链表：
public class LinkedQueue<E> {
static class Node<E> {
final E item;
final AtomicReference<Node<E>> next;
public Node() {
this(null, null);
}
public Node(E item, Node<E> next) {
this.item = item;
this.next = new AtomicReference<Node<E>>(next);
}
}
private final Node<E> dummy = new Node<E>();
private final AtomicReference<Node<E>> head = new AtomicReference<Node<E>>(dummy);
private final AtomicReference<Node<E>> tail = new AtomicReference<Node<E>>(dummy);
public boolean put(E item) {
Node<E> newNode = new Node<E>(item, null);
while (true) {
Node<E> curTailNode = tail.get();
Node<E> tailNextNode = curTailNode.next.get();
if (curTailNode == tail.get()) {
if (tailNextNode == null) {
// 更新尾节点下一个节点
if (curTailNode.next.compareAndSet(null, newNode)) {
// 更新成功, 将尾节点指向下一个节点
tail.compareAndSet(curTailNode, newNode);
return true;
}
} else {
// 在更新过程中, 发现尾节点的下一个节点被更新了, 将尾节点指向下一个节点
tail.compareAndSet(curTailNode, tailNextNode);
}
}
}
}
public static void main(String[] args) {
final LinkedQueue<String> queue = new LinkedQueue<String>();
new Thread(new Runnable() {
@Override
public void run() {
queue.put("item1");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
queue.put("item2");
}
}).start();
}
}
