Java并发编程读写锁

那什么是读写锁呢？

1.允许多个线程同时读共享变量；
2.只允许一个线程写共享变量；
3.如果一个写线程正在执行写操作，此时禁止读线程读共享变量。
Java SDK 并发包提供了读写锁——ReadWriteLock
先来看看接口定义,读锁和写锁

	public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

Java自带并发包有三个实现

由于CycleDetectingReentrantReadWriteLock是继承ReentrantReadWriteLock
先不讲，重点就在ReentrantReadWriteLock和 StampedLock

ReentrantReadWriteLock使用方法

	public class ReadWriteLockTest {

    private static final ReadWriteLock lock = new ReentrantReadWriteLock();

    private static Integer data = null;

    public static void main(String[] args) {
        Lock r = lock.readLock();
        Lock w = lock.writeLock();
        try{
            //获取读锁
            r.lock();
            //先查缓存
            Integer data = getData();
            if(data != null){
                //返回缓存数据
                return;
            }
        }finally {
            //释放读锁
            r.unlock();
        }
        try {
            //写锁上锁
            w.lock();
            //此处仍需查询一次缓存，当并发过高时，仍然存在多个读锁同时释放并且在 写锁前等待竞争
            //但是由于只能同时一个线程获取到写锁，当第一个写锁释放，第二个线程仍然会调用写锁
            //如果不查询缓存仍会出现多次写入现象
            Integer data = getData();
            if(data != null){
                //返回缓存数据
                return;
            }
            //读取数据库
            //写入缓存
        }finally {
            //释放写锁
            w.unlock();
        }
    }
    
    public static Integer getData(){
        return data;
    }
 }

说完使用，来看一下
Lock w = lock.writeLock();
//写锁上锁
w.lock();
读锁lock的实现

此处同步策略又分公平和非公平，可以去了解一下
先搞定NonfairSync



自旋锁一：!tryAcquire(arg)

getState 0表示尚未有任何线程持有锁，为正表示持有该锁的线程重入次数，而这里则表示当前可用许可数available；

acquires传进来的值恒定为1(arg)
条件一：remaining < 0 等于只要有一个线程获取写锁就会自旋等待释放锁，此条件才会成立，否则会继续等待
条件二:compareAndSetState(available, remaining)
该方法的解释

自旋锁二：
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
addWaiter(Node.EXCLUSIVE)把当前

添加写锁节点

上一个节点是否等于当前节点，等于则说明暂无线程占用写锁

读锁类似，当有写锁占用时，则等待写锁释放才能获取到读锁
结论：查看源码发现底层均由cas自旋来实现读写锁的操作，通过死循环来进行等待,直到满足条件跳出。支持多个线程同时读，但是当多个线程同时读的时候，所有的写操作会被阻塞

StampedLock