深刻学习Lock锁（4）——读写锁ReadWriteLock接口

1.简介

    如ReentrantLock都是排他锁，这些锁在同一时刻只容许一个线程进行访问，而读写锁在同一时刻能够容许多个读线程访问，可是在写线程访问时，全部的读线程和其余写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，经过分离读锁和写锁，使得并发性相比通常的排他锁有了很大提高。

    在没有读写锁以前，只能经过Java的等待通知机制，就是当写操做开始时，全部晚于写操做的读操做均会进入等待状态，只有写操做完成并进行通知以后，全部等待的读操做才能继续执行（写操做之间依靠synchronized关键进行同步），这样作的目的是使读操做能读取到正确的数据，不会出现脏读。改用读写锁实现上述功能，只须要在读操做时获取读锁，写操做时获取写锁便可。当写锁被获取到时，后续（非当前写 操做线程）的读写操做都会被阻塞，写锁释放以后，全部操做继续执行。

    Java并发包提供读写锁接口ReadWriteLock的实现是 ReentrantReadWriteLock。其具备的特性包括：

1. 公平性选择：支持非公平和公平的获取锁方式。但非公平的吞吐量大于公平的。
2. 重入锁：支持重入锁，即获取读锁以后还能再次获取读锁，获取写锁后还能再次获取读锁或写锁。
3. 锁降级：容许获取写锁，获取读锁，释放写锁的次序，即写锁能够降级为读锁。

2.读写锁的接口与示例

   1. ReentrantReadWriteLock相关API：ReadWriteLock仅定义了获取读锁和写锁的两个方法，即readLock()方法和writeLock()方法，而其实现——ReentrantReadWriteLock，除了接口方法以外，还提供了一些便于外界监控其内部工做状态的方法。如

    （1）public int getReadLockCount()：返回当前读锁被获取的次数，但不是占用该锁的线程数，也就是说，一个线程若是n次获取该锁，该方法返回n，而不是1。

    （2） public int getReadHoldCount()：返回当前线程获取读锁的次数。

    （3） public boolean isWriteLocked()：判断写锁是否被获取。

    （4）public int getWriteHoldCount()：获取写锁被获取的次数。

    2.读写锁使用实例：

public class TestReadWriteLock {
	static ReadWriteLock lock=new ReentrantReadWriteLock();
	static Lock read=lock.readLock();
	static Lock write=lock.writeLock();
	static HashMap<String, Object> map=new HashMap<String, Object>();
	static Object get(String key){
		read.lock();
		try {
			return map.get(key);
		} finally {
			read.unlock();
		}
	}
	static void put(String key,Object value){
		write.lock();
		try {
			map.put(key, value);
		} finally {
			write.unlock();
		}
	}
	static void clear(){
		write.lock();
		try {
			map.clear();
		} finally {
			write.unlock();
		}
	}
}

    以一个非线程安全的HashMap实现了一个简单的线程安全的HashMap，在读操做get(String key)方法中，须要获取读锁，这使 得并发访问该方法时不会被阻塞。写操做put(String key,Object value)方法和clear()方法，在更新HashMap时必须提早获取写锁，当获取写锁后，其余线程对于读锁和写锁的获取均被阻塞，而 只有写锁被释放以后，其余读写操做才能继续。

3.读写锁底层实现

1.读写状态表示同步状态

    读写锁一样依赖自定义同步器来实现同步功能，而读写状态就是其同步器的同步状态。以ReentrantLock中自定义同步器的实现为例，同步状态表示锁被一个线程重复获取的次数，而读写锁的自定义同步器须要在同步状态（一个整型变量）上维护多个读线程和一个写线程的状态，使得该状态的设计成为读写锁实现的关键。

    在一个整形变量中维护多个状态，须要使用“按位切割方法”，在读写锁中，咱们须要将一个整形变量表示为读和写两种状态，因此会将整型变量分割为两部分，高16位表示读状态，低16为表示写状态。

    经过位运算即可以肯定读写状态。假设当前同步状态值为S，写状态等于S&0x0000FFFF（将高16位所有抹去），读状态等于S>>>16（无符号补0右移 16位）。当写状态增长1时，等于S+1，当读状态增长1时，等于S+(1<<16)，也就是 S+0x00010000。

2.写锁的获取与释放

    写锁是一个支持重进入的排它锁。若是当前线程已经获取了写锁，则增长写状态。若是当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者该线程不是已经获取写锁的线程， 则当前线程进入等待状态，源码以下：

final boolean tryWriteLock() {
            Thread current = Thread.currentThread();
            int c = getState();
            if (c != 0) {
                int w = exclusiveCount(c);
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                if (w == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
            }
            if (!compareAndSetState(c, c + 1))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

    该方法除了重入条件（当前线程为获取了写锁的线程）以外，增长了一个读锁是否存在的判断。若是存在读锁，则写锁不能被获取，缘由在于：读写锁要确保写锁的操做对读锁可见，若是容许读锁在已被获取的状况下对写锁的获取，那么正在运行的其余读线程就没法感知到当前写线程的操做。所以，只有等待其余读线程都释放了读锁，写锁才能被当前线程获取，而写锁一旦被获取，则其余读写线程的后续访问均被阻塞。

    写锁的释放与ReentrantLock的释放过程基本相似，每次释放均减小写状态，当写状态为0时表示写锁已被释放，从而等待的读写线程可以继续访问读写锁，同时前次写线程的修改对后续读写线程可见。

3.读锁的获取与释放

    读锁是一个支持重进入的共享锁，它可以被多个线程同时获取，在没有其余写线程访问 （或者写状态为0）时，读锁总会被成功地获取，而所作的也只是（线程安全的）增长读状态。若是当前线程已经获取了读锁，则增长读状态。若是当前线程在获取读锁时，写锁已被其余线程 获取，则进入等待状态。源码以下：

final boolean tryReadLock() {
            Thread current = Thread.currentThread();
            for (;;) {
                int c = getState();
                if (exclusiveCount(c) != 0 &&
                    getExclusiveOwnerThread() != current)
                    return false;
                int r = sharedCount(c);
                if (r == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    if (r == 0) {
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    } else if (firstReader == current) {
                        firstReaderHoldCount++;
                    } else {
                        HoldCounter rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current))
                            cachedHoldCounter = rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                    }
                    return true;
                }
            }
        }

    读状态是全部线程获取读锁次数的总和，而每一个线程各自获取读锁的次数只能选择保存在ThreadLocal中，由线程自身维护。

    在tryAcquireShared(int unused)方法中，若是其余线程已经获取了写锁，则当前线程获取读锁失败，进入等待状态。若是当前线程获取了写锁或者写锁未被获取，则当前线程（线程安全， 依靠CAS保证）增长读状态，成功获取读锁。 读锁的每次释放（线程安全的，可能有多个读线程同时释放读锁）均减小读状态，减小的值是（1<<16）。

4.锁降级

    锁降级指的是写锁降级成为读锁。若是当前线程拥有写锁，而后将其释放，最后再获取读锁，这种分段完成的过程不能称之为锁降级。锁降级是指把持住（当前拥有的）写锁，再获取到 读锁，随后释放（先前拥有的）写锁的过程。

static Object putAndget(String key,Object value){
		write.lock();
		try {
			read.lock();
			map.put(key, value);
		} finally {
			write.unlock();
		}
		try {
			return map.get(key);
		} finally {
			read.unlock();
		}
		
	}