多线程、锁，可重入，同步，原子性，可见性，非阻塞算法

问题1 什么是Re-entrant Lock

锁的acquire是per thread 的， 而不是per call的，也就是同一个线程再次申请已经获得的锁，直接成功返回。如果是非re-entrant的锁，一个线程试图获取已经获得的锁会死锁，因为当前线程会挂起，没有机会release锁

synchronized的锁和 ReentrantLock都是 Re-entrant Lock

问题2：java已经有了synchronized，为什么还要在jdk1.5中加入Lock系列?

ReentrantLock 和 synchronized有相同的语义，但是有更高的性能，ReentrantLock 使用原子变量来维护等待锁定的线程队列。

synchronized获取锁的时候只能一直等，没有超时机制，也不能被打断，而且锁的获取和释放必须在一个方法内

而ReentrantLock的lock方法和synchronized是等同语义的，还可以通过tryLock等方法有多种选择，并且以接口和类的形式而不是语言feature的形式存在，更好扩展。

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

Lock的确缺点是必须在finally块中 unlock

问题3：AtomicInteger 主要解决原子性，那可见性呢？需要用volatile声明吗？

AtomicInteger 内部维护的那个int值是用volatile声明的，所以也AtomicInteger也保证了可见性，不需要再用volatile声明

注意：可见性保证只有两个办法，就是synchronized和 volatile

问题4：一个int 成员变量，一个方法赋值，一个方法读值，多线程环境下，需要同步吗？

需要同步，或者用volatile，并且读操作也需要同步。赋值和读值是原子的，但是依旧有可见性问题，否则也许读方法永远都不到最新的值。为什么数据库查询也需要事务？也是可见性问题。

问题5：用最小的开销实现实现计数器

@ThreadSafe
public class CheesyCounter {
    // Employs the cheap read-write lock trick
    // All mutative operations MUST be done with the 'this' lock held
    @GuardedBy("this") private volatile int value;

    public int getValue() { return value; }

    public synchronized int increment() {
        return ++value;
    }
}

++value是非原子操作（典型的 读取-修改-写回）用synchronized 保证原子性(也可以用ReentrantLock) ，getValue是原子的，可见性问题由volatile保证了。假如不用volatile那个简单的读取也要用锁

问题6 volatile的经典应用场景

1）对变量的操作是原子的，（注意原子操作只有赋值和读取，即“=”操作符，++value不是）

2）只有一个线程写，这样就不会产生更新丢失问题，

具体的，最经典的应用就是flag，即第一种场景。 比如一个死循环的服务线程，通过外部线程设置 exit 的flag决定是否退出。

问题7 用ReentrantLock代替synchronized后， 需要用wait, notify的时候怎么办？

众所周知，wait和notify必须放在synchronized块里，现在用了Lock了怎么办？答案是Lock的Condition，也就是用了不需要用Object.wait()了

问题8 锁的等待队列，是先申请的线程先获取吗？

ReentrantLock的构造函数有一个参数，指定这个锁是fair的还是unfair的，fair的意思是说按申请锁的先后顺序排队，先到先得，而unfair的锁不保证这一点。默认是unfair的。 而且，内置的synchronized锁是unfair的，也就是其实先申请锁的线程不一定先执行！

fair的锁比较慢，几种并发模式的性能比较 Fair ReentrantLock < synchronized < Unfair ReentrantLock < 非阻塞算法

问题9 非阻塞算法原理

一般基于CAS, (campare and set/swap)，用一个while循环，先读取old value,  然后计算新值，在更新的时候看target 变量的值是否还是oldvalue，如果是，说明没有别的线程干扰，执行更新，否则有别的线程更新过，while回去重新来一遍。注意这里的“看target 变量是否还是oldvalue并且更新”是一个原子操作CAS。

public class NonblockingCounter {
    private AtomicInteger value;
    public int getValue() {
        return value.get();
    }
    public int increment() {
        int v;
        do {
            v = value.get();
        while (!value.compareAndSet(v, v + 1));
        return v + 1;
    }
}

无锁堆栈

class ConcurrentStack<E> {
    AtomicReference<Node> head = new AtomicReference<Node>();
    public void push(E item) {
        Node newHead = new Node(item);
        Node oldHead;
        do {
            oldHead = head.get();
            newHead.next = oldHead;
        } while (!head.compareAndSet(oldHead, newHead));
    }
    public E pop() {
        Node oldHead;
        Node newHead;
        do {
            oldHead = head.get();
            if (oldHead == null) 
                return null;
            newHead = oldHead.next;
        } while (!head.compareAndSet(oldHead,newHead));
        return oldHead.item;
    }
    class Node {
        final E item;
        Node next;
        public Node(E item) { this.item = item; }
    }
}