JAVA中的锁（三）-读写锁

//返回当前读锁被获取的次数。该次数不等于获取读锁的线程数。
//例如仅一个线程，它连续获取(重进入)了n次读锁，那么占据读锁的线程数是1，但该方法返回n
int getReadLockCount()
  
//返回当前线程获取读锁的次数。该方法在java6中加入到ReentrantReadWriteLock中，
//使用ThreadLocal保存当前线程获取的次数，这也使得java6变得更加复杂
int getReadHoldCount()
 
//返回当前写锁被获取的次数
int getWriteHoldCount()  
  
//判断写锁是否被获取
int isWriteLocked()

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Cache {
	static Map<String, Object> map = new HashMap<>();
	static ReentrantReadWriteLock rw1 = new ReentrantReadWriteLock();
	static Lock r = rw1.readLock();
	static Lock w = rw1.writeLock();

	//获取一个key对应的value
	public static final Object get(String key) {
		r.lock();
		try {
			return map.get(key);
		} finally {
			r.unlock();
		}
	}
	
	//设置key对应的value，并返回就的value
	public static final Object put(String key, Object value) {
		w.lock();
		try {
			return map.put(key, value);
		} finally {
			w.unlock();
		}
	}
	
	//清空所有的内容
	public static final void clear() {
		w.lock();
		try {
			map.clear();
		} finally {
			w.unlock();
		}
	}
}

protected final boolean tryAcquire(int acquires) {
    /*
     * Walkthrough:
     * 1. If read count nonzero or write count nonzero
     *    and owner is a different thread, fail.
     * 2. If count would saturate, fail. (This can only
     *    happen if count is already nonzero.)
     * 3. Otherwise, this thread is eligible for lock if
     *    it is either a reentrant acquire or
     *    queue policy allows it. If so, update state
     *    and set owner.
     */
    Thread current = Thread.currentThread();
    int c = getState();
    int w = exclusiveCount(c);
    if (c != 0) {
        // (Note: if c != 0 and w == 0 then shared count != 0)
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        // Reentrant acquire
        setState(c + acquires);
        return true;
    }
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    setExclusiveOwnerThread(current);
    return true;
}

protected final int tryAcquireShared(int unused) {
  	for(;;) {
      	int c = getState();
      	int nextc = c + (1<<16);
      	if (nextc < c) {
          	throw new Error("Maximum lock count exceeded");
      	}
      	if (exclusiveCount(c)!=0 && owner!=Thread.currentThread()) {
          	return -1;
      	}
      	if (compareAndSetState(c, nextc)) {
          	return 1;
      	}
  	}
}

public void processData() {
	readLock.lock();
	if (!update) {
		//必须先释放读锁
		readLock.unlock();
		
		//锁降级从写锁获取到开始
		writeLock.lock();
		try {
			if (!update) {
				//准备数据的流程（略）
				// TODO
				update = true;
			}
			readLock.lock();
		} finally {
			writeLock.unlock();
		}
	}
	
	try {
		//使用数据的流程（略）
		// TODO
	} finally {
		readLock.unlock();
	}
}